diff --git a/src/systemc/dt/bit/SConscript b/src/systemc/dt/bit/SConscript
new file mode 100644
index 0000000..ed6eb35
--- /dev/null
+++ b/src/systemc/dt/bit/SConscript
@@ -0,0 +1,34 @@
+# Copyright 2018 Google, Inc.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met: redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer;
+# redistributions in binary form must reproduce the above copyright
+# notice, this list of conditions and the following disclaimer in the
+# documentation and/or other materials provided with the distribution;
+# neither the name of the copyright holders nor the names of its
+# 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
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+# Authors: Gabe Black
+
+Import('*')
+
+if env['USE_SYSTEMC']:
+    Source('sc_bit.cc')
+    Source('sc_bv_base.cc')
+    Source('sc_logic.cc')
+    Source('sc_lv_base.cc')
diff --git a/src/systemc/dt/bit/sc_bit.cc b/src/systemc/dt/bit/sc_bit.cc
new file mode 100644
index 0000000..7300b0d
--- /dev/null
+++ b/src/systemc/dt/bit/sc_bit.cc
@@ -0,0 +1,127 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_bit.cpp -- Bit class.
+
+  Original Author: Gene Bushuyev, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: sc_bit.cpp,v $
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.6  2006/04/12 20:17:52  acg
+//  Andy Goodrich: enabled deprecation message for sc_bit.
+//
+// Revision 1.5  2006/01/25 00:31:15  acg
+//  Andy Goodrich: Changed over to use a standard message id of
+//  SC_ID_IEEE_1666_DEPRECATION for all deprecation messages.
+//
+// Revision 1.4  2006/01/24 20:50:55  acg
+// Andy Goodrich: added warnings indicating that sc_bit is deprecated and that
+// the C bool data type should be used in its place.
+//
+// Revision 1.3  2006/01/13 18:53:53  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#include <sstream>
+
+#include "systemc/ext/dt/bit/sc_bit.hh"
+#include "systemc/ext/dt/bit/sc_logic.hh"
+#include "systemc/ext/utils/sc_report_handler.hh"
+
+namespace sc_dt
+{
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_bit
+//
+//  Bit class.
+//  Note: VSIA compatibility indicated.
+// ----------------------------------------------------------------------------
+
+// support methods
+void
+sc_bit::invalid_value(char c)
+{
+    std::stringstream msg;
+    msg << "sc_bit('" << c << "')";
+    SC_REPORT_ERROR("value is not valid", msg.str().c_str());
+    sc_core::sc_abort(); // can't recover from here
+}
+
+void
+sc_bit::invalid_value(int i)
+{
+    std::stringstream msg;
+    msg << "sc_bit(" << i << ")";
+    SC_REPORT_ERROR("value is not valid", msg.str().c_str());
+    sc_core::sc_abort(); // can't recover from here
+}
+
+// constructors
+sc_bit::sc_bit(const sc_logic &a) : m_val(a.to_bool()) // non-VSIA
+{
+   sc_deprecated_sc_bit();
+}
+
+// assignment operators
+sc_bit &
+sc_bit::operator = (const sc_logic &b) // non-VSIA
+{
+    return (*this = sc_bit(b));
+}
+
+// other methods
+void
+sc_bit::scan(::std::istream &is)
+{
+    bool b;
+    is >> b;
+    *this = b;
+}
+
+void
+sc_deprecated_sc_bit()
+{
+    static bool warn_sc_bit_deprecated = true;
+    if (warn_sc_bit_deprecated) {
+        warn_sc_bit_deprecated = false;
+        SC_REPORT_INFO("/IEEE_Std_1666/deprecated",
+            "sc_bit is deprecated, use bool instead");
+    }
+}
+
+} // namespace sc_dt
diff --git a/src/systemc/dt/bit/sc_bv_base.cc b/src/systemc/dt/bit/sc_bv_base.cc
new file mode 100644
index 0000000..84265af
--- /dev/null
+++ b/src/systemc/dt/bit/sc_bv_base.cc
@@ -0,0 +1,231 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_bv_base.cpp -- Arbitrary size bit vector class.
+
+  Original Author: Gene Bushuyev, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: sc_bv_base.cpp,v $
+// Revision 1.2  2011/08/24 22:05:40  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.4  2006/04/11 23:12:26  acg
+//   Andy Goodrich: Fixed bug in parsing of extended string constants like
+//   0bus1110011.
+//
+// Revision 1.3  2006/01/13 18:53:53  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#include <cstring>
+#include <sstream>
+
+#include "systemc/ext/dt/bit/sc_bv_base.hh"
+#include "systemc/ext/dt/fx/sc_fix.hh"
+#include "systemc/ext/dt/fx/sc_ufix.hh"
+#include "systemc/ext/utils/sc_report.hh"
+
+namespace sc_dt
+{
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_bv_base
+//
+//  Arbitrary size bit vector base class.
+// ----------------------------------------------------------------------------
+
+void
+sc_bv_base::init(int length_, bool init_value)
+{
+    // check the length
+    if (length_ <= 0) {
+        SC_REPORT_ERROR("zero length", 0);
+        sc_core::sc_abort(); // can't recover from here
+    }
+    // allocate memory for the data and control words
+    m_len = length_;
+    m_size = (m_len - 1) / SC_DIGIT_SIZE + 1;
+    m_data = new sc_digit[m_size];
+    // initialize the bits to 'init_value'
+    sc_digit dw = init_value ? ~SC_DIGIT_ZERO : SC_DIGIT_ZERO;
+    int sz = m_size;
+    for (int i = 0; i < sz; ++i) {
+        m_data[i] = dw;
+    }
+    clean_tail();
+}
+
+void
+sc_bv_base::assign_from_string(const std::string &s)
+{
+    // s must have been converted to bin
+    int len = m_len;
+    int s_len = s.length() - 1;
+    int min_len = sc_min(len, s_len);
+    int i = 0;
+    for (; i < min_len; ++i) {
+        char c = s[s_len - i - 1];
+        if (c != '0' && c != '1') {
+            SC_REPORT_ERROR("cannot perform conversion",
+                "string can contain only '0' and '1' characters");
+            // may continue, if suppressed
+            c = '0';
+        }
+        set_bit(i, sc_logic_value_t(c - '0'));
+    }
+    // if formatted, fill the rest with sign(s), otherwise fill with zeros
+    sc_logic_value_t fill = (s[s_len] == 'F' ? sc_logic_value_t(s[0] - '0')
+                                             : sc_logic_value_t(0));
+    for (; i < len; ++i) {
+        set_bit(i, fill);
+    }
+}
+
+// constructors
+sc_bv_base::sc_bv_base(const char *a) : m_len(0), m_size(0), m_data(0)
+{
+    std::string s = convert_to_bin(a);
+    init(s.length() - 1);
+    assign_from_string(s);
+}
+
+sc_bv_base::sc_bv_base(const char *a, int length_) :
+    m_len(0), m_size(0), m_data(0)
+{
+    init(length_);
+    assign_from_string(convert_to_bin(a));
+}
+
+sc_bv_base::sc_bv_base(const sc_bv_base &a) :
+    sc_proxy<sc_bv_base>(), m_len(a.m_len), m_size(a.m_size),
+    m_data(new sc_digit[m_size])
+{
+    // copy the bits
+    int sz = m_size;
+    for (int i = 0; i < sz; ++i) {
+        m_data[i] = a.m_data[i];
+    }
+}
+
+// assignment operators
+sc_bv_base &
+sc_bv_base::operator = (const char *a)
+{
+    assign_from_string(convert_to_bin(a));
+    return *this;
+}
+
+
+// ----------------------------------------------------------------------------
+// convert formatted string to binary string
+
+const std::string
+convert_to_bin(const char *s)
+{
+    // Beware: logic character strings cannot start with '0x' or '0X',
+    //         because this is seen as a hexadecimal encoding prefix!
+
+    if (s == 0) {
+        SC_REPORT_ERROR("cannot perform conversion",
+            "character string is zero");
+        return std::string();
+    }
+    if (*s == 0) {
+        SC_REPORT_ERROR("cannot perform conversion",
+            "character string is empty");
+        return std::string();
+    }
+
+    int n = strlen(s);
+    int i = 0;
+    if (s[0] == '-' || s[0] == '+') {
+        ++i;
+    }
+    if (n > (i + 2) && s[i] == '0') {
+        if (s[i + 1] == 'b' || s[i + 1] == 'B') {
+            if (s[i + 2] == '0' || s[i + 2] == '1') {
+                std::string str(&s[2]);
+                str += "F";
+                return str;
+            }
+        }
+        if (s[i + 1] == 'b' || s[i + 1] == 'B' ||
+            s[i + 1] == 'c' || s[i + 1] == 'C' ||
+            s[i + 1] == 'd' || s[i + 1] == 'D' ||
+            s[i + 1] == 'o' || s[i + 1] == 'O' ||
+            s[i + 1] == 'x' || s[i + 1] == 'X') {
+            try {
+                // worst case length = n * 4
+                sc_fix a(s, n * 4, n * 4, SC_TRN, SC_WRAP, 0, SC_ON);
+                std::string str = a.to_bin();
+                str += "F"; // mark the string as formatted
+                // get rid of prefix (0b) and redundant leading bits
+                const char *p = str.c_str() + 2;
+                while (p[1] && p[0] == p[1]) {
+                    ++p;
+                }
+                return std::string(p);
+            } catch (const sc_core::sc_report &) {
+                std::stringstream msg;
+                msg << "character string '" << s << "' is not valid";
+                SC_REPORT_ERROR("cannot perform conversion",
+                        msg.str().c_str());
+                return std::string();
+            }
+        }
+    }
+
+    // bin by default
+    std::string str(s);
+    str += "U"; // mark the string as unformatted
+    return str;
+}
+
+// convert binary string to formatted string
+const std::string
+convert_to_fmt(const std::string &s, sc_numrep numrep, bool w_prefix)
+{
+    int n = s.length();
+    std::string str("0bus");
+    // str += "0bus";
+    str += s;
+    sc_ufix a(str.c_str(), n, n, SC_TRN, SC_WRAP, 0, SC_ON);
+    return a.to_string(numrep, w_prefix);
+}
+
+} // namespace sc_dt
diff --git a/src/systemc/dt/bit/sc_logic.cc b/src/systemc/dt/bit/sc_logic.cc
new file mode 100644
index 0000000..81663fc
--- /dev/null
+++ b/src/systemc/dt/bit/sc_logic.cc
@@ -0,0 +1,166 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_logic.cpp -- C++ implementation of logic type. Behaves
+                  pretty much the same way as HDLs logic type.
+
+  Original Author: Stan Y. Liao, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: sc_logic.cpp,v $
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:53  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#include <sstream>
+
+#include "systemc/ext/dt/bit/sc_logic.hh"
+#include "systemc/ext/utils/sc_report_handler.hh"
+
+namespace sc_dt
+{
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_logic
+//
+//  Four-valued logic type.
+// ----------------------------------------------------------------------------
+
+// support methods
+void
+sc_logic::invalid_value(sc_logic_value_t v)
+{
+    invalid_value((int)v);
+}
+
+void
+sc_logic::invalid_value(char c)
+{
+    std::stringstream msg;
+    msg << "sc_logic('" << c << "')";
+    SC_REPORT_ERROR("value is not valid", msg.str().c_str());
+}
+
+void
+sc_logic::invalid_value(int i)
+{
+    std::stringstream msg;
+    msg << "sc_logic(" << i << ")";
+    SC_REPORT_ERROR("value is not valid", msg.str().c_str());
+}
+
+
+void
+sc_logic::invalid_01() const
+{
+    if ((int)m_val == Log_Z) {
+        SC_REPORT_WARNING("sc_logic value 'Z' cannot be converted to bool", 0);
+    } else {
+        SC_REPORT_WARNING("sc_logic value 'X' cannot be converted to bool", 0);
+    }
+}
+
+
+// conversion tables
+const sc_logic_value_t sc_logic::char_to_logic[128] = {
+    Log_0, Log_1, Log_Z, Log_X, Log_X, Log_X, Log_X, Log_X,
+    Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X,
+    Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X,
+    Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X,
+    Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X,
+    Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X,
+    Log_0, Log_1, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X,
+    Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X,
+    Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X,
+    Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X,
+    Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X,
+    Log_X, Log_X, Log_Z, Log_X, Log_X, Log_X, Log_X, Log_X,
+    Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X,
+    Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X,
+    Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X, Log_X,
+    Log_X, Log_X, Log_Z, Log_X, Log_X, Log_X, Log_X, Log_X
+};
+
+const char sc_logic::logic_to_char[4] = { '0', '1', 'Z', 'X' };
+
+const sc_logic_value_t sc_logic::and_table[4][4] = {
+    { Log_0, Log_0, Log_0, Log_0 },
+    { Log_0, Log_1, Log_X, Log_X },
+    { Log_0, Log_X, Log_X, Log_X },
+    { Log_0, Log_X, Log_X, Log_X }
+};
+
+const sc_logic_value_t sc_logic::or_table[4][4] = {
+    { Log_0, Log_1, Log_X, Log_X },
+    { Log_1, Log_1, Log_1, Log_1 },
+    { Log_X, Log_1, Log_X, Log_X },
+    { Log_X, Log_1, Log_X, Log_X }
+};
+
+const sc_logic_value_t sc_logic::xor_table[4][4] = {
+    { Log_0, Log_1, Log_X, Log_X },
+    { Log_1, Log_0, Log_X, Log_X },
+    { Log_X, Log_X, Log_X, Log_X },
+    { Log_X, Log_X, Log_X, Log_X }
+};
+
+const sc_logic_value_t sc_logic::not_table[4] = {
+    Log_1, Log_0, Log_X, Log_X
+};
+
+// other methods
+void
+sc_logic::scan(::std::istream &is)
+{
+    char c;
+    is >> c;
+    *this = c;
+}
+
+// #ifdef SC_DT_DEPRECATED
+const sc_logic sc_logic_0(Log_0);
+const sc_logic sc_logic_1(Log_1);
+const sc_logic sc_logic_Z(Log_Z);
+const sc_logic sc_logic_X(Log_X);
+// #endif
+
+const sc_logic SC_LOGIC_0(Log_0);
+const sc_logic SC_LOGIC_1(Log_1);
+const sc_logic SC_LOGIC_Z(Log_Z);
+const sc_logic SC_LOGIC_X(Log_X);
+
+} // namespace sc_dt
diff --git a/src/systemc/dt/bit/sc_lv_base.cc b/src/systemc/dt/bit/sc_lv_base.cc
new file mode 100644
index 0000000..9ffa505
--- /dev/null
+++ b/src/systemc/dt/bit/sc_lv_base.cc
@@ -0,0 +1,180 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_lv_base.cpp -- Arbitrary size logic vector class.
+
+  Original Author: Gene Bushuyev, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: sc_lv_base.cpp,v $
+// Revision 1.2  2011/08/24 22:05:40  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:53  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#include <sstream>
+
+#include "systemc/ext/dt/bit/sc_lv_base.hh"
+
+namespace sc_dt
+{
+
+// explicit template instantiations
+template class sc_proxy<sc_lv_base>;
+template class sc_proxy<sc_bv_base>;
+
+void
+sc_proxy_out_of_bounds(const char *msg, int64 val)
+{
+    std::stringstream ss;
+    if (msg != NULL)
+        ss << msg;
+    if (val != 0)
+        ss << val;
+    SC_REPORT_ERROR("out of bounds", ss.str().c_str());
+}
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_lv_base
+//
+//  Arbitrary size logic vector base class.
+// ----------------------------------------------------------------------------
+
+static const sc_digit data_array[] = {
+    SC_DIGIT_ZERO, ~SC_DIGIT_ZERO, SC_DIGIT_ZERO, ~SC_DIGIT_ZERO
+};
+
+static const sc_digit ctrl_array[] = {
+    SC_DIGIT_ZERO, SC_DIGIT_ZERO, ~SC_DIGIT_ZERO, ~SC_DIGIT_ZERO
+};
+
+void
+sc_lv_base::init(int length_, const sc_logic& init_value)
+{
+    // check the length
+    if (length_ <= 0) {
+        SC_REPORT_ERROR("zero length", 0);
+        sc_core::sc_abort(); // can't recover from here
+    }
+    // allocate memory for the data and control words
+    m_len = length_;
+    m_size = (m_len - 1) / SC_DIGIT_SIZE + 1;
+    m_data = new sc_digit[m_size * 2];
+    m_ctrl = m_data + m_size;
+    // initialize the bits to 'init_value'
+    sc_digit dw = data_array[init_value.value()];
+    sc_digit cw = ctrl_array[init_value.value()];
+    int sz = m_size;
+    for (int i = 0; i < sz; ++i) {
+        m_data[i] = dw;
+        m_ctrl[i] = cw;
+    }
+    clean_tail();
+}
+
+void
+sc_lv_base::assign_from_string(const std::string &s)
+{
+    // s must have been converted to bin
+    int len = m_len;
+    int s_len = s.length() - 1;
+    int min_len = sc_min(len, s_len);
+    int i = 0;
+    for (; i < min_len; ++i) {
+        char c = s[s_len - i - 1];
+        set_bit(i, sc_logic::char_to_logic[(int)c]);
+    }
+    // if formatted, fill the rest with sign(s), otherwise fill with zeros
+    sc_logic_value_t fill = (s[s_len] == 'F' ? sc_logic_value_t(s[0] - '0')
+                                             : sc_logic_value_t(0));
+    for (; i < len; ++i) {
+        set_bit(i, fill);
+    }
+}
+
+// constructors
+sc_lv_base::sc_lv_base(const char *a) :
+    m_len(0), m_size(0), m_data(0), m_ctrl(0)
+{
+    std::string s = convert_to_bin(a);
+    init(s.length() - 1);
+    assign_from_string(s);
+}
+
+sc_lv_base::sc_lv_base(const char *a, int length_) :
+    m_len(0), m_size(0), m_data(0), m_ctrl(0)
+{
+    init(length_);
+    assign_from_string(convert_to_bin(a));
+}
+
+sc_lv_base::sc_lv_base(const sc_lv_base &a) :
+    sc_proxy<sc_lv_base>(), m_len(a.m_len), m_size(a.m_size),
+      m_data(new sc_digit[m_size * 2]), m_ctrl(m_data + m_size)
+{
+    // copy the bits
+    int sz = m_size;
+    for (int i = 0; i < sz; ++i) {
+        m_data[i] = a.m_data[i];
+        m_ctrl[i] = a.m_ctrl[i];
+    }
+}
+
+// assignment operators
+sc_lv_base &
+sc_lv_base::operator = (const char *a)
+{
+    assign_from_string(convert_to_bin(a));
+    return *this;
+}
+
+// returns true if logic vector contains only 0's and 1's
+bool
+sc_lv_base::is_01() const
+{
+    int sz = m_size;
+    for (int i = 0; i < sz; ++i) {
+        if (m_ctrl[i] != 0) {
+            return false;
+        }
+    }
+    return true;
+}
+
+} // namespace sc_dt
diff --git a/src/systemc/dt/fx/SConscript b/src/systemc/dt/fx/SConscript
new file mode 100644
index 0000000..698496c
--- /dev/null
+++ b/src/systemc/dt/fx/SConscript
@@ -0,0 +1,41 @@
+# Copyright 2018 Google, Inc.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met: redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer;
+# redistributions in binary form must reproduce the above copyright
+# notice, this list of conditions and the following disclaimer in the
+# documentation and/or other materials provided with the distribution;
+# neither the name of the copyright holders nor the names of its
+# 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
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+# Authors: Gabe Black
+
+Import('*')
+
+if env['USE_SYSTEMC']:
+    Source('sc_fxcast_switch.cc')
+    Source('sc_fxdefs.cc')
+    Source('scfx_mant.cc')
+    Source('sc_fxnum.cc')
+    Source('sc_fxnum_observer.cc')
+    Source('scfx_pow10.cc')
+    Source('scfx_rep.cc')
+    Source('sc_fxtype_params.cc')
+    Source('scfx_utils.cc')
+    Source('sc_fxval.cc')
+    Source('sc_fxval_observer.cc')
diff --git a/src/systemc/dt/fx/sc_fxcast_switch.cc b/src/systemc/dt/fx/sc_fxcast_switch.cc
new file mode 100644
index 0000000..9aabe14
--- /dev/null
+++ b/src/systemc/dt/fx/sc_fxcast_switch.cc
@@ -0,0 +1,86 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_fxcast_switch.cpp -
+
+  Original Author: Martin Janssen, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date: Gene Bushuyev, Synopsys, Inc.
+  Description of Modification: - fix explicit instantiation syntax.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: sc_fxcast_switch.cpp,v $
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:57  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#include "systemc/ext/dt/fx/sc_fxcast_switch.hh"
+
+namespace sc_dt
+{
+
+template class sc_global<sc_fxcast_switch>;
+template class sc_context<sc_fxcast_switch>;
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxcast_switch
+//
+//  Fixed-point cast switch class.
+// ----------------------------------------------------------------------------
+
+const std::string
+sc_fxcast_switch::to_string() const
+{
+    return sc_dt::to_string(m_sw);
+}
+
+void
+sc_fxcast_switch::print(::std::ostream &os) const
+{
+    os << sc_dt::to_string(m_sw);
+}
+
+void
+sc_fxcast_switch::dump(::std::ostream &os) const
+{
+    os << "sc_fxcast_switch" << ::std::endl;
+    os << "(" << ::std::endl;
+    os << "sw = " << sc_dt::to_string(m_sw) << ::std::endl;
+    os << ")" << ::std::endl;
+}
+
+} // namespace sc_dt
diff --git a/src/systemc/dt/fx/sc_fxdefs.cc b/src/systemc/dt/fx/sc_fxdefs.cc
new file mode 100644
index 0000000..4a9e745
--- /dev/null
+++ b/src/systemc/dt/fx/sc_fxdefs.cc
@@ -0,0 +1,166 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_fxdefs.cpp -
+
+  Original Author: Martin Janssen, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: sc_fxdefs.cpp,v $
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:57  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#include "systemc/ext/dt/fx/sc_fxdefs.hh"
+
+namespace sc_dt
+{
+
+// ----------------------------------------------------------------------------
+//  ENUM : sc_enc
+//
+//  Enumeration of sign encodings.
+// ----------------------------------------------------------------------------
+
+const std::string
+to_string(sc_enc enc)
+{
+    switch (enc) {
+        case SC_TC_:
+            return std::string("SC_TC_");
+        case SC_US_:
+            return std::string("SC_US_");
+        default:
+            return std::string("unknown");
+    }
+}
+
+// ----------------------------------------------------------------------------
+//  ENUM : sc_q_mode
+//
+//  Enumeration of quantization modes.
+// ----------------------------------------------------------------------------
+
+const std::string
+to_string(sc_q_mode q_mode)
+{
+    switch (q_mode) {
+        case SC_RND:
+            return std::string("SC_RND");
+        case SC_RND_ZERO:
+            return std::string("SC_RND_ZERO");
+        case SC_RND_MIN_INF:
+            return std::string("SC_RND_MIN_INF");
+        case SC_RND_INF:
+            return std::string("SC_RND_INF");
+        case SC_RND_CONV:
+            return std::string("SC_RND_CONV");
+        case SC_TRN:
+            return std::string("SC_TRN");
+        case SC_TRN_ZERO:
+            return std::string("SC_TRN_ZERO");
+        default:
+            return std::string("unknown");
+    }
+}
+
+// ----------------------------------------------------------------------------
+//  ENUM : sc_o_mode
+//
+//  Enumeration of overflow modes.
+// ----------------------------------------------------------------------------
+
+const std::string
+to_string(sc_o_mode o_mode)
+{
+    switch (o_mode) {
+        case SC_SAT:
+            return std::string("SC_SAT");
+        case SC_SAT_ZERO:
+            return std::string("SC_SAT_ZERO");
+        case SC_SAT_SYM:
+            return std::string("SC_SAT_SYM");
+        case SC_WRAP:
+            return std::string("SC_WRAP");
+        case SC_WRAP_SM:
+            return std::string("SC_WRAP_SM");
+        default:
+            return std::string("unknown");
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  ENUM : sc_switch
+//
+//  Enumeration of switch states.
+// ----------------------------------------------------------------------------
+
+const std::string
+to_string(sc_switch sw)
+{
+    switch (sw) {
+        case SC_OFF:
+            return std::string("SC_OFF");
+        case SC_ON:
+            return std::string("SC_ON");
+        default:
+            return std::string("unknown");
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  ENUM : sc_fmt
+//
+//  Enumeration of formats for character string conversion.
+// ----------------------------------------------------------------------------
+
+const std::string
+to_string(sc_fmt fmt)
+{
+    switch (fmt) {
+        case SC_F:
+            return std::string("SC_F");
+        case SC_E:
+            return std::string("SC_E");
+        default:
+            return std::string("unknown");
+    }
+}
+
+} // namespace sc_dt
diff --git a/src/systemc/dt/fx/sc_fxnum.cc b/src/systemc/dt/fx/sc_fxnum.cc
new file mode 100644
index 0000000..f47b4d3
--- /dev/null
+++ b/src/systemc/dt/fx/sc_fxnum.cc
@@ -0,0 +1,867 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_fxnum.cpp -
+
+  Original Author: Martin Janssen, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: sc_fxnum.cpp,v $
+// Revision 1.3  2011/01/19 18:57:40  acg
+//  Andy Goodrich: changes for IEEE_1666_2011.
+//
+// Revision 1.2  2010/12/07 20:09:08  acg
+// Andy Goodrich: Philipp Hartmann's constructor disambiguation fix
+//
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:57  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#include <cmath>
+
+#include "systemc/ext/dt/fx/sc_fxnum.hh"
+
+namespace sc_dt
+{
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxnum_bitref
+//
+//  Proxy class for bit-selection in class sc_fxnum, behaves like sc_bit.
+// ----------------------------------------------------------------------------
+
+bool sc_fxnum_bitref::get() const { return m_num.get_bit(m_idx); }
+void sc_fxnum_bitref::set(bool high) { m_num.set_bit(m_idx, high); }
+
+// print or dump content
+void sc_fxnum_bitref::print(::std::ostream &os) const { os << get(); }
+
+void
+sc_fxnum_bitref::scan(::std::istream &is)
+{
+    bool b;
+    is >> b;
+    *this = b;
+}
+
+void
+sc_fxnum_bitref::dump(::std::ostream &os) const
+{
+    os << "sc_fxnum_bitref" << ::std::endl;
+    os << "(" << ::std::endl;
+    os << "num = ";
+    m_num.dump(os);
+    os << "idx = " << m_idx << ::std::endl;
+    os << ")" << ::std::endl;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxnum_fast_bitref
+//
+//  Proxy class for bit-selection in class sc_fxnum_fast, behaves like sc_bit.
+// ----------------------------------------------------------------------------
+
+bool sc_fxnum_fast_bitref::get() const { return m_num.get_bit(m_idx); }
+void sc_fxnum_fast_bitref::set(bool high) { m_num.set_bit(m_idx, high); }
+
+// print or dump content
+void sc_fxnum_fast_bitref::print(::std::ostream &os) const { os << get(); }
+
+void
+sc_fxnum_fast_bitref::scan(::std::istream &is)
+{
+    bool b;
+    is >> b;
+    *this = b;
+}
+
+void
+sc_fxnum_fast_bitref::dump(::std::ostream &os) const
+{
+    os << "sc_fxnum_fast_bitref" << ::std::endl;
+    os << "(" << ::std::endl;
+    os << "num = ";
+    m_num.dump(os);
+    os << "idx = " << m_idx << ::std::endl;
+    os << ")" << ::std::endl;
+}
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxnum_subref
+//
+//  Proxy class for part-selection in class sc_fxnum,
+//  behaves like sc_bv_base.
+// ----------------------------------------------------------------------------
+
+bool
+sc_fxnum_subref::get() const
+{
+    return m_num.get_slice(m_from, m_to, m_bv);
+}
+
+bool
+sc_fxnum_subref::set()
+{
+    return m_num.set_slice(m_from, m_to, m_bv);
+}
+
+// print or dump content
+void
+sc_fxnum_subref::print(::std::ostream &os) const
+{
+    get();
+    m_bv.print(os);
+}
+
+void
+sc_fxnum_subref::scan(::std::istream &is)
+{
+    m_bv.scan(is);
+    set();
+}
+
+void
+sc_fxnum_subref::dump(::std::ostream &os) const
+{
+    os << "sc_fxnum_subref" << ::std::endl;
+    os << "(" << ::std::endl;
+    os << "num  = ";
+    m_num.dump(os);
+    os << "from = " << m_from << ::std::endl;
+    os << "to   = " << m_to << ::std::endl;
+    os << ")" << ::std::endl;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxnum_fast_subref
+//
+//  Proxy class for part-selection in class sc_fxnum_fast,
+//  behaves like sc_bv_base.
+// ----------------------------------------------------------------------------
+
+bool
+sc_fxnum_fast_subref::get() const
+{
+    return m_num.get_slice(m_from, m_to, m_bv);
+}
+
+bool
+sc_fxnum_fast_subref::set()
+{
+    return m_num.set_slice(m_from, m_to, m_bv);
+}
+
+// print or dump content
+void
+sc_fxnum_fast_subref::print(::std::ostream &os) const
+{
+    get();
+    m_bv.print(os);
+}
+
+void
+sc_fxnum_fast_subref::scan(::std::istream &is)
+{
+    m_bv.scan(is);
+    set();
+}
+
+void
+sc_fxnum_fast_subref::dump(::std::ostream &os) const
+{
+    os << "sc_fxnum_fast_subref" << ::std::endl;
+    os << "(" << ::std::endl;
+    os << "num  = ";
+    m_num.dump(os);
+    os << "from = " << m_from << ::std::endl;
+    os << "to   = " << m_to << ::std::endl;
+    os << ")" << ::std::endl;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxnum
+//
+//  Base class for the fixed-point types; arbitrary precision.
+// ----------------------------------------------------------------------------
+
+// explicit conversion to character string
+
+const std::string
+sc_fxnum::to_string() const
+{
+    return std::string(m_rep->to_string(SC_DEC, -1, SC_F, &m_params));
+}
+
+const std::string
+sc_fxnum::to_string(sc_numrep numrep) const
+{
+    return std::string(m_rep->to_string(numrep, -1, SC_F, &m_params));
+}
+
+const std::string
+sc_fxnum::to_string(sc_numrep numrep, bool w_prefix) const
+{
+    return std::string(m_rep->to_string(numrep, (w_prefix ? 1 : 0),
+                                        SC_F, &m_params));
+}
+
+const std::string
+sc_fxnum::to_string(sc_fmt fmt) const
+{
+    return std::string(m_rep->to_string(SC_DEC, -1, fmt, &m_params));
+}
+
+const std::string
+sc_fxnum::to_string(sc_numrep numrep, sc_fmt fmt) const
+{
+    return std::string(m_rep->to_string(numrep, -1, fmt, &m_params));
+}
+
+const std::string
+sc_fxnum::to_string(sc_numrep numrep, bool w_prefix, sc_fmt fmt) const
+{
+    return std::string(m_rep->to_string(numrep, (w_prefix ? 1 : 0),
+                                        fmt, &m_params));
+}
+
+
+const std::string
+sc_fxnum::to_dec() const
+{
+    return std::string(m_rep->to_string(SC_DEC, -1, SC_F, &m_params));
+}
+
+const std::string
+sc_fxnum::to_bin() const
+{
+    return std::string(m_rep->to_string(SC_BIN, -1, SC_F, &m_params));
+}
+
+const std::string
+sc_fxnum::to_oct() const
+{
+    return std::string(m_rep->to_string(SC_OCT, -1, SC_F, &m_params));
+}
+
+const std::string
+sc_fxnum::to_hex() const
+{
+    return std::string(m_rep->to_string(SC_HEX, -1, SC_F, &m_params));
+}
+
+
+// print or dump content
+void
+sc_fxnum::print(::std::ostream &os) const
+{
+    os << m_rep->to_string(SC_DEC, -1, SC_F, &m_params);
+}
+
+void
+sc_fxnum::scan(::std::istream &is)
+{
+    std::string s;
+    is >> s;
+    *this = s.c_str();
+}
+
+void
+sc_fxnum::dump(::std::ostream &os) const
+{
+    os << "sc_fxnum" << ::std::endl;
+    os << "(" << ::std::endl;
+    os << "rep      = ";
+    m_rep->dump(os);
+    os << "params   = ";
+    m_params.dump(os);
+    os << "q_flag   = " << m_q_flag << ::std::endl;
+    os << "o_flag   = " << m_o_flag << ::std::endl;
+    // TO BE COMPLETED
+    // os << "observer = ";
+    // if (m_observer != 0)
+    //     m_observer->dump(os);
+    // else
+    //     os << "0" << ::std::endl;
+    os << ")" << ::std::endl;
+}
+
+
+sc_fxnum_observer *
+sc_fxnum::lock_observer() const
+{
+    SC_ASSERT_(m_observer != 0, "lock observer failed");
+    sc_fxnum_observer * tmp = m_observer;
+    m_observer = 0;
+    return tmp;
+}
+
+void
+sc_fxnum::unlock_observer(sc_fxnum_observer *observer_) const
+{
+    SC_ASSERT_(observer_ != 0, "unlock observer failed");
+    m_observer = observer_;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxnum_fast
+//
+//  Base class for the fixed-point types; limited precision.
+// ----------------------------------------------------------------------------
+
+static void
+quantization(double &c, const scfx_params &params, bool &q_flag)
+{
+    int fwl = params.wl() - params.iwl();
+    double scale = scfx_pow2(fwl);
+    double val = scale * c;
+    double int_part;
+    double frac_part = modf(val, &int_part);
+
+    q_flag = (frac_part != 0.0);
+
+    if (q_flag) {
+        val = int_part;
+
+        switch (params.q_mode()) {
+          case SC_TRN: // truncation
+            {
+                if (c < 0.0)
+                    val -= 1.0;
+                break;
+            }
+          case SC_RND: // rounding to plus infinity
+            {
+                if (frac_part >= 0.5)
+                    val += 1.0;
+                else if (frac_part < -0.5)
+                    val -= 1.0;
+                break;
+            }
+          case SC_TRN_ZERO: // truncation to zero
+            {
+                break;
+            }
+          case SC_RND_INF: // rounding to infinity
+            {
+                if (frac_part >= 0.5)
+                    val += 1.0;
+                else if (frac_part <= -0.5)
+                    val -= 1.0;
+                break;
+            }
+          case SC_RND_CONV: // convergent rounding
+            {
+                if (frac_part > 0.5 ||
+                    (frac_part == 0.5 && fmod(int_part, 2.0) != 0.0)) {
+                    val += 1.0;
+                } else if (frac_part < -0.5 ||
+                           (frac_part == -0.5 && fmod(int_part, 2.0) != 0.0)) {
+                    val -= 1.0;
+                }
+                break;
+            }
+          case SC_RND_ZERO: // rounding to zero
+            {
+                if (frac_part > 0.5)
+                    val += 1.0;
+                else if (frac_part < -0.5)
+                    val -= 1.0;
+                break;
+            }
+          case SC_RND_MIN_INF: // rounding to minus infinity
+            {
+                if (frac_part > 0.5)
+                    val += 1.0;
+                else if (frac_part <= -0.5)
+                    val -= 1.0;
+                break;
+            }
+          default:
+            ;
+        }
+    }
+
+    val /= scale;
+    c = val;
+}
+
+static void
+overflow(double &c, const scfx_params &params, bool &o_flag)
+{
+    int iwl = params.iwl();
+    int fwl = params.wl() - iwl;
+    double full_circle = scfx_pow2(iwl);
+    double resolution = scfx_pow2(-fwl);
+    double low, high;
+    if (params.enc() == SC_TC_) {
+        high = full_circle / 2.0 - resolution;
+        if (params.o_mode() == SC_SAT_SYM)
+            low = - high;
+        else
+            low = - full_circle / 2.0;
+    } else {
+        low = 0.0;
+        high = full_circle - resolution;
+    }
+    double val = c;
+    sc_fxval_fast c2(c);
+
+    bool under = (val < low);
+    bool over = (val > high);
+
+    o_flag = (under || over);
+
+    if (o_flag) {
+        switch (params.o_mode()) {
+          case SC_WRAP: // wrap-around
+            {
+                int n_bits = params.n_bits();
+
+                if (n_bits == 0) {
+                    // wrap-around all 'wl' bits
+                    val -= floor(val / full_circle) * full_circle;
+                    if (val > high)
+                        val -= full_circle;
+                } else if (n_bits < params.wl()) {
+                    double X = scfx_pow2(iwl - n_bits);
+
+                    // wrap-around least significant 'wl - n_bits' bits
+                    val -= floor(val / X) * X;
+                    if (val > (X - resolution))
+                        val -= X;
+
+                    // saturate most significant 'n_bits' bits
+                    if (under) {
+                        val += low;
+                    } else {
+                        if (params.enc() == SC_TC_)
+                            val += full_circle / 2.0 - X;
+                        else
+                            val += full_circle - X;
+                    }
+                } else {
+                    // saturate all 'wl' bits
+                    if (under)
+                        val = low;
+                    else
+                        val = high;
+                }
+                break;
+            }
+          case SC_SAT: // saturation
+          case SC_SAT_SYM: // symmetrical saturation
+            {
+                if (under)
+                    val = low;
+                else
+                    val = high;
+                break;
+            }
+          case SC_SAT_ZERO: // saturation to zero
+            {
+                val = 0.0;
+                break;
+            }
+          case SC_WRAP_SM: // sign magnitude wrap-around
+            {
+                SC_ERROR_IF_(params.enc() == SC_US_,
+                             "SC_WRAP_SM not defined for unsigned numbers");
+
+                int n_bits = params.n_bits();
+
+                if (n_bits == 0) {
+                    // invert conditionally
+                    if (c2.get_bit(iwl) != c2.get_bit(iwl - 1))
+                        val = -val - resolution;
+
+                    // wrap-around all 'wl' bits
+                    val -= floor(val / full_circle) * full_circle;
+                    if (val > high)
+                        val -= full_circle;
+                } else if (n_bits == 1) {
+                    // invert conditionally
+                    if (c2.is_neg() != c2.get_bit(iwl - 1))
+                        val = -val - resolution;
+
+                    // wrap-around all 'wl' bits
+                    val -= floor(val / full_circle) * full_circle;
+                    if (val > high)
+                        val -= full_circle;
+                } else if (n_bits < params.wl()) {
+                    // invert conditionally
+                    if (c2.is_neg() == c2.get_bit(iwl - n_bits))
+                        val = -val - resolution;
+
+                    double X = scfx_pow2(iwl - n_bits);
+
+                    // wrap-around least significant 'wl - n_bits' bits
+                    val -= floor(val / X) * X;
+                    if (val > (X - resolution))
+                        val -= X;
+
+                    // saturate most significant 'n_bits' bits
+                    if (under)
+                        val += low;
+                    else
+                        val += full_circle / 2.0 - X;
+                } else {
+                    // saturate all 'wl' bits
+                    if (under)
+                        val = low;
+                    else
+                        val = high;
+                }
+                break;
+            }
+            default:
+                ;
+        }
+
+        c = val;
+    }
+}
+
+
+void
+sc_fxnum_fast::cast()
+{
+    scfx_ieee_double id(m_val);
+    SC_ERROR_IF_(id.is_nan() || id.is_inf(), "invalid fixed-point value");
+
+    if (m_params.cast_switch() == SC_ON) {
+        m_q_flag = false;
+        m_o_flag = false;
+
+        // check for special cases
+
+        if (id.is_zero()) {
+            if (id.negative() != 0)
+                m_val = -m_val;
+            return;
+        }
+
+        // perform casting
+        sc_dt::quantization(m_val, m_params, m_q_flag);
+        sc_dt::overflow(m_val, m_params, m_o_flag);
+
+        // check for special case: -0
+        id = m_val;
+        if (id.is_zero() && id.negative() != 0) {
+            m_val = -m_val;
+        }
+
+        // check for special case: NaN of Inf
+        if (id.is_nan() || id.is_inf()) {
+            m_val = 0.0;
+        }
+    }
+}
+
+
+// defined in sc_fxval.cpp;
+extern const char* to_string(const scfx_ieee_double &, sc_numrep, int, sc_fmt,
+                             const scfx_params * =0);
+
+
+// explicit conversion to character string
+
+const std::string
+sc_fxnum_fast::to_string() const
+{
+    return std::string(sc_dt::to_string(m_val, SC_DEC, -1, SC_F, &m_params));
+}
+
+const std::string
+sc_fxnum_fast::to_string(sc_numrep numrep) const
+{
+    return std::string(sc_dt::to_string(m_val, numrep, -1, SC_F, &m_params));
+}
+
+const std::string
+sc_fxnum_fast::to_string(sc_numrep numrep, bool w_prefix) const
+{
+    return std::string(sc_dt::to_string(m_val, numrep, (w_prefix ? 1 : 0),
+                                        SC_F, &m_params));
+}
+
+const std::string
+sc_fxnum_fast::to_string(sc_fmt fmt) const
+{
+    return std::string(sc_dt::to_string(m_val, SC_DEC, -1, fmt, &m_params));
+}
+
+const std::string
+sc_fxnum_fast::to_string(sc_numrep numrep, sc_fmt fmt) const
+{
+    return std::string(sc_dt::to_string(m_val, numrep, -1, fmt, &m_params));
+}
+
+const std::string
+sc_fxnum_fast::to_string(sc_numrep numrep, bool w_prefix, sc_fmt fmt) const
+{
+    return std::string(sc_dt::to_string(m_val, numrep, (w_prefix ? 1 : 0),
+                                        fmt, &m_params));
+}
+
+
+const std::string
+sc_fxnum_fast::to_dec() const
+{
+    return std::string(sc_dt::to_string(m_val, SC_DEC, -1, SC_F, &m_params));
+}
+
+const std::string
+sc_fxnum_fast::to_bin() const
+{
+    return std::string(sc_dt::to_string(m_val, SC_BIN, -1, SC_F, &m_params));
+}
+
+const std::string
+sc_fxnum_fast::to_oct() const
+{
+    return std::string(sc_dt::to_string(m_val, SC_OCT, -1, SC_F, &m_params));
+}
+
+const std::string
+sc_fxnum_fast::to_hex() const
+{
+    return std::string(sc_dt::to_string(m_val, SC_HEX, -1, SC_F, &m_params));
+}
+
+// print or dump content
+void
+sc_fxnum_fast::print(::std::ostream &os) const
+{
+    os << sc_dt::to_string(m_val, SC_DEC, -1, SC_F, &m_params);
+}
+
+void
+sc_fxnum_fast::scan(::std::istream &is)
+{
+    std::string s;
+    is >> s;
+    *this = s.c_str();
+}
+
+void
+sc_fxnum_fast::dump(::std::ostream &os) const
+{
+    os << "sc_fxnum_fast" << ::std::endl;
+    os << "(" << ::std::endl;
+    os << "val      = " << m_val << ::std::endl;
+    os << "params   = ";
+    m_params.dump(os);
+    os << "q_flag   = " << m_q_flag << ::std::endl;
+    os << "o_flag   = " << m_o_flag << ::std::endl;
+    // TO BE COMPLETED
+    // os << "observer = ";
+    // if (m_observer != 0)
+    //     m_observer->dump(os);
+    // else
+    //     os << "0" << ::std::endl;
+    os << ")" << ::std::endl;
+}
+
+// internal use only;
+bool
+sc_fxnum_fast::get_bit(int i) const
+{
+    scfx_ieee_double id(m_val);
+    if (id.is_zero() || id.is_nan() || id.is_inf())
+        return false;
+
+    // convert to two's complement
+    unsigned int m0 = id.mantissa0();
+    unsigned int m1 = id.mantissa1();
+
+    if (id.is_normal())
+        m0 += 1U << 20;
+
+    if (id.negative() != 0) {
+        m0 = ~ m0;
+        m1 = ~ m1;
+        unsigned int tmp = m1;
+        m1 += 1U;
+        if (m1 <= tmp)
+            m0 += 1U;
+    }
+
+    // get the right bit
+    int j = i - id.exponent();
+    if ((j += 20) >= 32)
+        return ((m0 & 1U << 31) != 0);
+    else if (j >= 0)
+        return ((m0 & 1U << j) != 0);
+    else if ((j += 32) >= 0)
+        return ((m1 & 1U << j) != 0);
+    else
+        return false;
+}
+
+
+bool
+sc_fxnum_fast::set_bit(int i, bool high)
+{
+    scfx_ieee_double id(m_val);
+    if (id.is_nan() || id.is_inf())
+        return false;
+
+    if (high) {
+        if (get_bit(i))
+            return true;
+
+        if (m_params.enc() == SC_TC_ && i == m_params.iwl() - 1)
+            m_val -= scfx_pow2(i);
+        else
+            m_val += scfx_pow2(i);
+    } else {
+        if (!get_bit(i))
+            return true;
+
+        if (m_params.enc() == SC_TC_ && i == m_params.iwl() - 1)
+            m_val += scfx_pow2(i);
+        else
+            m_val -= scfx_pow2(i);
+    }
+
+    return true;
+}
+
+
+bool
+sc_fxnum_fast::get_slice(int i, int j, sc_bv_base &bv) const
+{
+    scfx_ieee_double id(m_val);
+    if (id.is_nan() || id.is_inf())
+        return false;
+
+    // convert to two's complement
+    unsigned int m0 = id.mantissa0();
+    unsigned int m1 = id.mantissa1();
+
+    if (id.is_normal())
+        m0 += 1U << 20;
+
+    if (id.negative() != 0) {
+        m0 = ~ m0;
+        m1 = ~ m1;
+        unsigned int tmp = m1;
+        m1 += 1U;
+        if (m1 <= tmp)
+            m0 += 1U;
+    }
+
+    // get the bits
+    int l = j;
+    for (int k = 0; k < bv.length(); ++ k) {
+        bool b = false;
+
+        int n = l - id.exponent();
+        if ((n += 20) >= 32)
+            b = ((m0 & 1U << 31) != 0);
+        else if (n >= 0)
+            b = ((m0 & 1U << n) != 0);
+        else if ((n += 32) >= 0)
+            b = ((m1 & 1U << n) != 0);
+
+        bv[k] = b;
+
+        if (i >= j)
+            ++l;
+        else
+            --l;
+    }
+
+    return true;
+}
+
+bool
+sc_fxnum_fast::set_slice(int i, int j, const sc_bv_base &bv)
+{
+    scfx_ieee_double id(m_val);
+    if (id.is_nan() || id.is_inf())
+        return false;
+
+    // set the bits
+    int l = j;
+    for (int k = 0; k < bv.length(); ++k) {
+        if (bv[k].to_bool()) {
+            if (!get_bit(l)) {
+                if (m_params.enc() == SC_TC_ && l == m_params.iwl() - 1)
+                    m_val -= scfx_pow2(l);
+                else
+                    m_val += scfx_pow2(l);
+            }
+        } else {
+            if (get_bit(l)) {
+                if (m_params.enc() == SC_TC_ && l == m_params.iwl() - 1)
+                    m_val += scfx_pow2(l);
+                else
+                    m_val -= scfx_pow2(l);
+            }
+        }
+
+        if (i >= j)
+            ++l;
+        else
+            --l;
+    }
+
+    return true;
+}
+
+sc_fxnum_fast_observer *
+sc_fxnum_fast::lock_observer() const
+{
+    SC_ASSERT_(m_observer != 0, "lock observer failed");
+    sc_fxnum_fast_observer *tmp = m_observer;
+    m_observer = 0;
+    return tmp;
+}
+
+void
+sc_fxnum_fast::unlock_observer(sc_fxnum_fast_observer *observer_) const
+{
+    SC_ASSERT_(observer_ != 0, "unlock observer failed");
+    m_observer = observer_;
+}
+
+} // namespace sc_dt
diff --git a/src/systemc/dt/fx/sc_fxnum_observer.cc b/src/systemc/dt/fx/sc_fxnum_observer.cc
new file mode 100644
index 0000000..1ee3c9b
--- /dev/null
+++ b/src/systemc/dt/fx/sc_fxnum_observer.cc
@@ -0,0 +1,70 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_fxnum_observer.cpp -
+
+  Original Author: Martin Janssen, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: sc_fxnum_observer.cpp,v $
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:58  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#include "systemc/ext/dt/fx/sc_fxnum_observer.hh"
+
+namespace sc_dt
+{
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxnum_observer
+//
+//  Abstract base class for fixed-point types observers; arbitrary precision.
+// ----------------------------------------------------------------------------
+
+sc_fxnum_observer *(* sc_fxnum_observer::default_observer) () = 0;
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxnum_fast_observer
+//
+//  Abstract base class for fixed-point types observers; limited precision.
+// ----------------------------------------------------------------------------
+
+sc_fxnum_fast_observer *(* sc_fxnum_fast_observer::default_observer) () = 0;
+
+} // namespace sc_dt
diff --git a/src/systemc/dt/fx/sc_fxtype_params.cc b/src/systemc/dt/fx/sc_fxtype_params.cc
new file mode 100644
index 0000000..54af8a7
--- /dev/null
+++ b/src/systemc/dt/fx/sc_fxtype_params.cc
@@ -0,0 +1,97 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_fxtype_params.cpp -
+
+  Original Author: Martin Janssen, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: sc_fxtype_params.cpp,v $
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:58  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#include <sstream>
+
+#include "systemc/ext/dt/fx/sc_fxtype_params.hh"
+
+namespace sc_dt
+{
+
+template class sc_global<sc_fxtype_params>;
+template class sc_context<sc_fxtype_params>;
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxtype_params
+//
+//  Fixed-point type parameters class.
+// ----------------------------------------------------------------------------
+
+const std::string
+sc_fxtype_params::to_string() const
+{
+    std::stringstream ss;
+    print(ss);
+    return ss.str();
+}
+
+void
+sc_fxtype_params::print(::std::ostream &os) const
+{
+    os << "("
+       << m_wl << ","
+       << m_iwl << ","
+       << m_q_mode << ","
+       << m_o_mode << ","
+       << m_n_bits
+       << ")";
+}
+
+void
+sc_fxtype_params::dump(::std::ostream &os) const
+{
+    os << "sc_fxtype_params" << ::std::endl;
+    os << "(" << ::std::endl;
+    os << "wl = " << m_wl << ::std::endl;
+    os << "iwl = " << m_iwl << ::std::endl;
+    os << "q_mode = " << m_q_mode << ::std::endl;
+    os << "o_mode = " << m_o_mode << ::std::endl;
+    os << "n_bits = " << m_n_bits << ::std::endl;
+    os << ")" << ::std::endl;
+}
+
+} // namespace sc_dt
diff --git a/src/systemc/dt/fx/sc_fxval.cc b/src/systemc/dt/fx/sc_fxval.cc
new file mode 100644
index 0000000..45d7d57
--- /dev/null
+++ b/src/systemc/dt/fx/sc_fxval.cc
@@ -0,0 +1,810 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_fxval.cpp -
+
+  Original Author: Martin Janssen, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: sc_fxval.cpp,v $
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:58  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#include <cctype>
+#include <cfloat>
+#include <cmath>
+#include <cstdlib>
+
+#include "systemc/ext/dt/fx/sc_fxval.hh"
+
+namespace sc_dt
+{
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxval
+//
+//  Fixed-point value type; arbitrary precision.
+// ----------------------------------------------------------------------------
+
+// explicit conversion to character string
+
+const std::string
+sc_fxval::to_string() const
+{
+    return std::string(m_rep->to_string(SC_DEC, -1, SC_E));
+}
+
+const std::string
+sc_fxval::to_string(sc_numrep numrep) const
+{
+    return std::string(m_rep->to_string(numrep, -1, SC_E));
+}
+
+const std::string
+sc_fxval::to_string(sc_numrep numrep, bool w_prefix) const
+{
+    return std::string(m_rep->to_string(numrep, (w_prefix ? 1 : 0), SC_E));
+}
+
+const std::string
+sc_fxval::to_string(sc_fmt fmt) const
+{
+    return std::string(m_rep->to_string(SC_DEC, -1, fmt));
+}
+
+const std::string
+sc_fxval::to_string(sc_numrep numrep, sc_fmt fmt) const
+{
+    return std::string(m_rep->to_string(numrep, -1, fmt));
+}
+
+const std::string
+sc_fxval::to_string(sc_numrep numrep, bool w_prefix, sc_fmt fmt) const
+{
+    return std::string(m_rep->to_string(numrep, (w_prefix ? 1 : 0), fmt));
+}
+
+
+const std::string
+sc_fxval::to_dec() const
+{
+    return std::string(m_rep->to_string(SC_DEC, -1, SC_E));
+}
+
+const std::string
+sc_fxval::to_bin() const
+{
+    return std::string(m_rep->to_string(SC_BIN, -1, SC_E));
+}
+
+const std::string
+sc_fxval::to_oct() const
+{
+    return std::string(m_rep->to_string(SC_OCT, -1, SC_E));
+}
+
+const std::string
+sc_fxval::to_hex() const
+{
+    return std::string(m_rep->to_string(SC_HEX, -1, SC_E));
+}
+
+
+// print or dump content
+
+void sc_fxval::print(::std::ostream &os) const { m_rep->print(os); }
+
+void
+sc_fxval::scan(::std::istream &is)
+{
+    std::string s;
+    is >> s;
+    *this = s.c_str();
+}
+
+void
+sc_fxval::dump(::std::ostream &os) const
+{
+    os << "sc_fxval" << ::std::endl;
+    os << "(" << ::std::endl;
+    os << "rep = ";
+    m_rep->dump(os);
+    // TO BE COMPLETED
+    // os << "r_flag   = " << m_r_flag << ::std::endl;
+    // os << "observer = ";
+    // if (m_observer != 0)
+    //     m_observer->dump(os);
+    // else
+    //     os << "0" << ::std::endl;
+    os << ")" << ::std::endl;
+}
+
+// protected methods and friend functions
+sc_fxval_observer *
+sc_fxval::lock_observer() const
+{
+    SC_ASSERT_(m_observer != 0, "lock observer failed");
+    sc_fxval_observer *tmp = m_observer;
+    m_observer = 0;
+    return tmp;
+}
+
+void
+sc_fxval::unlock_observer(sc_fxval_observer *observer_) const
+{
+    SC_ASSERT_(observer_ != 0, "unlock observer failed");
+    m_observer = observer_;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxval_fast
+//
+//  Fixed-point value types; limited precision.
+// ----------------------------------------------------------------------------
+
+static void
+print_dec(scfx_string &s, scfx_ieee_double id, int w_prefix, sc_fmt fmt)
+{
+    if (id.negative() != 0) {
+        id.negative(0);
+        s += '-';
+    }
+
+    if (w_prefix == 1) {
+        scfx_print_prefix(s, SC_DEC);
+    }
+
+    if (id.is_zero()) {
+        s += '0';
+        return;
+    }
+
+    // split 'id' into its integer and fractional part
+    double int_part;
+    double frac_part = std::modf(static_cast<double>(id), &int_part);
+
+    int i;
+
+    // print integer part
+    int int_digits = 0;
+    int int_zeros  = 0;
+
+    if (int_part != 0.0) {
+        int_digits = (int)std::ceil(std::log10(int_part + 1.0));
+
+        int len = s.length();
+        s.append(int_digits);
+
+        bool zero_digits = (frac_part == 0.0 && fmt != SC_F);
+
+        for (i = int_digits + len - 1; i >= len; i--) {
+            unsigned int remainder = (unsigned int)std::fmod(int_part, 10.0);
+            s[i] = static_cast<char>('0' + remainder);
+
+            if (zero_digits) {
+                if (remainder == 0)
+                    int_zeros++;
+                else
+                    zero_digits = false;
+            }
+
+            int_part /= 10.0;
+        }
+
+        // discard trailing zeros from int_part
+        s.discard(int_zeros);
+
+        if (s[len] == '0') {
+            // int_digits was overestimated by one
+            s.remove(len);
+            --int_digits;
+        }
+    }
+
+    // print fractional part
+    int frac_digits = 0;
+    int frac_zeros  = 0;
+
+    if (frac_part != 0.0) {
+        s += '.';
+
+        bool zero_digits = (int_digits == 0 && fmt != SC_F);
+
+        frac_zeros = (int)std::floor(-std::log10(frac_part + DBL_EPSILON));
+
+        frac_part *= std::pow(10.0, frac_zeros);
+
+        frac_digits = frac_zeros;
+        if (!zero_digits) {
+            for (i = 0; i < frac_zeros; i++)
+                s += '0';
+            frac_zeros = 0;
+        }
+
+        while (frac_part != 0.0) {
+            frac_part *= 10.0;
+            int n = static_cast<int>(frac_part);
+
+            if (zero_digits) {
+                if (n == 0)
+                    frac_zeros++;
+                else
+                    zero_digits = false;
+            }
+
+            if (!zero_digits)
+                s += static_cast<char>('0' + n);
+
+            frac_part -= n;
+            frac_digits++;
+        }
+    }
+
+    // print exponent
+    if (fmt != SC_F) {
+        if (frac_digits == 0)
+            scfx_print_exp(s, int_zeros);
+        else if (int_digits == 0)
+            scfx_print_exp(s, -frac_zeros);
+    }
+}
+
+static void
+print_other(scfx_string &s, const scfx_ieee_double &id, sc_numrep numrep,
+             int w_prefix, sc_fmt fmt, const scfx_params *params)
+{
+    scfx_ieee_double id2 = id;
+
+    sc_numrep numrep2 = numrep;
+
+    bool numrep_is_sm = (numrep == SC_BIN_SM ||
+                         numrep == SC_OCT_SM ||
+                         numrep == SC_HEX_SM);
+
+    if (numrep_is_sm) {
+        if (id2.negative() != 0) {
+            s += '-';
+            id2.negative(0);
+        }
+        switch (numrep) {
+          case SC_BIN_SM:
+            numrep2 = SC_BIN_US;
+            break;
+          case SC_OCT_SM:
+            numrep2 = SC_OCT_US;
+            break;
+          case SC_HEX_SM:
+            numrep2 = SC_HEX_US;
+            break;
+          default:
+            ;
+        }
+    }
+
+    if (w_prefix != 0) {
+        scfx_print_prefix(s, numrep);
+    }
+
+    numrep = numrep2;
+
+    sc_fxval_fast a(id2);
+
+    int msb, lsb;
+
+    if (params != 0) {
+        msb = params->iwl() - 1;
+        lsb = params->iwl() - params->wl();
+
+        if (params->enc() == SC_TC_ &&
+            (numrep == SC_BIN_US ||
+              numrep == SC_OCT_US ||
+              numrep == SC_HEX_US) &&
+            !numrep_is_sm &&
+            params->wl() > 1) {
+            --msb;
+        } else if (params->enc() == SC_US_ &&
+            (numrep == SC_BIN ||
+              numrep == SC_OCT ||
+              numrep == SC_HEX ||
+              numrep == SC_CSD)) {
+            ++msb;
+        }
+    } else {
+        if (a.is_zero()) {
+            msb = 0;
+            lsb = 0;
+        } else {
+            msb = id2.exponent() + 1;
+            while (a.get_bit(msb) == a.get_bit(msb - 1))
+                --msb;
+
+            if (numrep == SC_BIN_US ||
+                numrep == SC_OCT_US ||
+                numrep == SC_HEX_US) {
+                --msb;
+            }
+
+            lsb = id2.exponent() - 52;
+            while (!a.get_bit(lsb))
+                ++lsb;
+        }
+    }
+
+    int step;
+
+    switch (numrep) {
+      case SC_BIN:
+      case SC_BIN_US:
+      case SC_CSD:
+        step = 1;
+       break;
+      case SC_OCT:
+      case SC_OCT_US:
+        step = 3;
+        break;
+      case SC_HEX:
+      case SC_HEX_US:
+        step = 4;
+        break;
+      default:
+        SC_REPORT_FATAL("assertion failed", "unexpected sc_numrep");
+        sc_core::sc_abort();
+    }
+
+    msb = (int)std::ceil(double(msb + 1) / step) * step - 1;
+
+    lsb = (int)std::floor(double(lsb) / step) * step;
+
+    if (msb < 0) {
+        s += '.';
+        if (fmt == SC_F) {
+            int sign = (id2.negative() != 0) ? (1 << step) - 1 : 0;
+            for (int i = (msb + 1) / step; i < 0; i++) {
+                if (sign < 10)
+                    s += static_cast<char>(sign + '0');
+                else
+                    s += static_cast<char>(sign + 'a' - 10);
+            }
+        }
+    }
+
+    int i = msb;
+    while (i >= lsb) {
+        int value = 0;
+        for (int j = step - 1; j >= 0; --j) {
+            value += static_cast<int>(a.get_bit(i)) << j;
+            --i;
+        }
+        if (value < 10)
+            s += static_cast<char>(value + '0');
+        else
+            s += static_cast<char>(value + 'a' - 10);
+        if (i == -1)
+            s += '.';
+    }
+
+    if (lsb > 0 && fmt == SC_F) {
+        for (int i = lsb / step; i > 0; i--)
+            s += '0';
+    }
+
+    if (s[s.length() - 1] == '.')
+        s.discard(1);
+
+    if (fmt != SC_F) {
+        if (msb < 0)
+            scfx_print_exp(s, (msb + 1) / step);
+        else if (lsb > 0)
+            scfx_print_exp(s, lsb / step);
+    }
+
+    if (numrep == SC_CSD)
+        scfx_tc2csd(s, w_prefix);
+}
+
+const char *
+to_string(const scfx_ieee_double &id, sc_numrep numrep, int w_prefix,
+          sc_fmt fmt, const scfx_params *params=0)
+{
+    static scfx_string s;
+
+    s.clear();
+
+    if (id.is_nan()) {
+        scfx_print_nan(s);
+    } else if (id.is_inf()) {
+        scfx_print_inf(s, static_cast<bool>(id.negative()));
+    } else if (id.negative() && !id.is_zero() &&
+             (numrep == SC_BIN_US ||
+               numrep == SC_OCT_US ||
+               numrep == SC_HEX_US)) {
+        s += "negative";
+    } else if (numrep == SC_DEC) {
+        sc_dt::print_dec(s, id, w_prefix, fmt);
+    } else {
+        sc_dt::print_other(s, id, numrep, w_prefix, fmt, params);
+    }
+
+    return s;
+}
+
+
+// explicit conversion to character string
+const std::string
+sc_fxval_fast::to_string() const
+{
+    return std::string(sc_dt::to_string(m_val, SC_DEC, -1, SC_E));
+}
+
+const std::string
+sc_fxval_fast::to_string(sc_numrep numrep) const
+{
+    return std::string(sc_dt::to_string(m_val, numrep, -1, SC_E));
+}
+
+const std::string
+sc_fxval_fast::to_string(sc_numrep numrep, bool w_prefix) const
+{
+    return std::string(sc_dt::to_string(m_val, numrep, (w_prefix ? 1 : 0),
+                       SC_E));
+}
+
+const std::string
+sc_fxval_fast::to_string(sc_fmt fmt) const
+{
+    return std::string(sc_dt::to_string(m_val, SC_DEC, -1, fmt));
+}
+
+const std::string
+sc_fxval_fast::to_string(sc_numrep numrep, sc_fmt fmt) const
+{
+    return std::string(sc_dt::to_string(m_val, numrep, -1, fmt));
+}
+
+const std::string
+sc_fxval_fast::to_string(sc_numrep numrep, bool w_prefix, sc_fmt fmt) const
+{
+    return std::string(sc_dt::to_string(m_val, numrep, (w_prefix ? 1 : 0),
+                                        fmt));
+}
+
+const std::string
+sc_fxval_fast::to_dec() const
+{
+    return std::string(sc_dt::to_string(m_val, SC_DEC, -1, SC_E));
+}
+
+const std::string
+sc_fxval_fast::to_bin() const
+{
+    return std::string(sc_dt::to_string(m_val, SC_BIN, -1, SC_E));
+}
+
+const std::string
+sc_fxval_fast::to_oct() const
+{
+    return std::string(sc_dt::to_string(m_val, SC_OCT, -1, SC_E));
+}
+
+const std::string
+sc_fxval_fast::to_hex() const
+{
+    return std::string(sc_dt::to_string(m_val, SC_HEX, -1, SC_E));
+}
+
+
+// print or dump content
+
+void
+sc_fxval_fast::print(::std::ostream &os) const
+{
+    os << sc_dt::to_string(m_val, SC_DEC, -1, SC_E);
+}
+
+void
+sc_fxval_fast::scan(::std::istream &is)
+{
+    std::string s;
+    is >> s;
+    *this = s.c_str();
+}
+
+void
+sc_fxval_fast::dump(::std::ostream &os) const
+{
+    os << "sc_fxval_fast" << ::std::endl;
+    os << "(" << ::std::endl;
+    os << "val = " << m_val << ::std::endl;
+    // TO BE COMPLETED
+    // os << "r_flag   = " << m_r_flag << ::std::endl;
+    // os << "observer = ";
+    // if (m_observer != 0)
+    //     m_observer->dump(os);
+    // else
+    //     os << "0" << ::std::endl;
+    os << ")" << ::std::endl;
+}
+
+
+// internal use only;
+bool
+sc_fxval_fast::get_bit(int i) const
+{
+    scfx_ieee_double id(m_val);
+    if (id.is_zero() || id.is_nan() || id.is_inf())
+        return false;
+
+    // convert to two's complement
+    unsigned int m0 = id.mantissa0();
+    unsigned int m1 = id.mantissa1();
+
+    if (id.is_normal())
+        m0 += 1U << 20;
+
+    if (id.negative() != 0) {
+        m0 = ~ m0;
+        m1 = ~ m1;
+        unsigned int tmp = m1;
+        m1 += 1U;
+        if (m1 <= tmp)
+            m0 += 1U;
+    }
+
+    // get the right bit
+    int j = i - id.exponent();
+    if ((j += 20) >= 32)
+        return ((m0 & 1U << 31) != 0);
+    else if (j >= 0)
+        return ((m0 & 1U << j) != 0);
+    else if ((j += 32) >= 0)
+        return ((m1 & 1U << j) != 0);
+    else
+        return false;
+}
+
+
+// protected methods and friend functions
+sc_fxval_fast_observer *
+sc_fxval_fast::lock_observer() const
+{
+    SC_ASSERT_(m_observer != 0, "lock observer failed");
+    sc_fxval_fast_observer *tmp = m_observer;
+    m_observer = 0;
+    return tmp;
+}
+
+void
+sc_fxval_fast::unlock_observer(sc_fxval_fast_observer *observer_) const
+{
+    SC_ASSERT_(observer_ != 0, "unlock observer failed");
+    m_observer = observer_;
+}
+
+#define SCFX_FAIL_IF_(cnd)                                                    \
+{                                                                             \
+    if ((cnd))                                                             \
+        return static_cast<double>(scfx_ieee_double::nan());                \
+}
+
+double
+sc_fxval_fast::from_string(const char *s)
+{
+    SCFX_FAIL_IF_(s == 0 || *s == 0);
+
+    scfx_string s2;
+    s2 += s;
+    s2 += '\0';
+
+    bool sign_char;
+    int sign = scfx_parse_sign(s, sign_char);
+
+    sc_numrep numrep = scfx_parse_prefix(s);
+
+    int base = 0;
+
+    switch (numrep) {
+      case SC_DEC:
+        {
+            base = 10;
+            if (scfx_is_nan(s)) // special case: NaN
+                return static_cast<double>(scfx_ieee_double::nan());
+            if (scfx_is_inf(s)) // special case: Infinity
+                return static_cast<double>(scfx_ieee_double::inf(sign));
+            break;
+        }
+      case SC_BIN:
+      case SC_BIN_US:
+        {
+            SCFX_FAIL_IF_(sign_char);
+            base = 2;
+            break;
+        }
+
+      case SC_BIN_SM:
+        {
+            base = 2;
+            break;
+        }
+      case SC_OCT:
+      case SC_OCT_US:
+        {
+            SCFX_FAIL_IF_(sign_char);
+            base = 8;
+            break;
+        }
+      case SC_OCT_SM:
+        {
+            base = 8;
+            break;
+        }
+      case SC_HEX:
+      case SC_HEX_US:
+        {
+            SCFX_FAIL_IF_(sign_char);
+            base = 16;
+            break;
+        }
+      case SC_HEX_SM:
+        {
+            base = 16;
+            break;
+        }
+      case SC_CSD:
+        {
+            SCFX_FAIL_IF_(sign_char);
+            base = 2;
+            scfx_csd2tc(s2);
+            s = (const char*) s2 + 4;
+            numrep = SC_BIN;
+            break;
+        }
+      default:;// Martin, what is default???
+    }
+
+    //
+    // find end of mantissa and count the digits and points
+    //
+
+    const char *end = s;
+    bool based_point = false;
+    int int_digits = 0;
+    int frac_digits = 0;
+
+    while (*end) {
+        if (scfx_exp_start(end))
+            break;
+
+        if (*end == '.') {
+            SCFX_FAIL_IF_(based_point);
+            based_point = true;
+        } else {
+            SCFX_FAIL_IF_(!scfx_is_digit(*end, numrep));
+            if (based_point)
+                frac_digits++;
+            else
+                int_digits++;
+        }
+
+        end++;
+    }
+
+    SCFX_FAIL_IF_(int_digits == 0 && frac_digits == 0);
+
+    // [ exponent ]
+    int exponent = 0;
+    if (*end) {
+        for (const char *e = end + 2; *e; e++)
+            SCFX_FAIL_IF_(!scfx_is_digit(*e, SC_DEC));
+        exponent = std::atoi(end + 1);
+    }
+
+    //
+    // convert the mantissa
+    //
+    double integer = 0.0;
+    if (int_digits != 0) {
+        bool first_digit = true;
+
+        for (; s < end; s++) {
+            if (*s == '.')
+                break;
+
+            if (first_digit) {
+                integer = scfx_to_digit(*s, numrep);
+                switch (numrep) {
+                  case SC_BIN:
+                  case SC_OCT:
+                  case SC_HEX:
+                    {
+                        if (integer >= (base >> 1))
+                            integer -= base; // two's complement
+                        break;
+                    }
+                  default:
+                    ;
+                }
+                first_digit = false;
+            } else {
+                integer *= base;
+                integer += scfx_to_digit(*s, numrep);
+            }
+        }
+    }
+
+    // [ . fraction ]
+    double fraction = 0.0;
+    if (frac_digits != 0) {
+        s++;  // skip '.'
+
+        bool first_digit = (int_digits == 0);
+        double scale = 1.0;
+        for (; s < end; s++) {
+            scale /= base;
+
+            if (first_digit) {
+                fraction = scfx_to_digit(*s, numrep);
+                switch (numrep) {
+                  case SC_BIN:
+                  case SC_OCT:
+                  case SC_HEX:
+                    {
+                        if (fraction >= (base >> 1))
+                            fraction -= base; // two's complement
+                        break;
+                    }
+                  default:
+                    ;
+                }
+                fraction *= scale;
+                first_digit = false;
+            } else {
+                fraction += scfx_to_digit(*s, numrep) * scale;
+            }
+        }
+    }
+
+    double exp =
+        (exponent != 0) ? std::pow((double) base, (double) exponent) : 1;
+
+    return (sign * (integer + fraction) * exp);
+}
+
+#undef SCFX_FAIL_IF_
+
+} // namespace sc_dt
diff --git a/src/systemc/dt/fx/sc_fxval_observer.cc b/src/systemc/dt/fx/sc_fxval_observer.cc
new file mode 100644
index 0000000..7b143ad
--- /dev/null
+++ b/src/systemc/dt/fx/sc_fxval_observer.cc
@@ -0,0 +1,72 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_fxval_observer.cpp -
+
+  Original Author: Martin Janssen, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: sc_fxval_observer.cpp,v $
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:58  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#include "systemc/ext/dt/fx/sc_fxval_observer.hh"
+
+namespace sc_dt
+{
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxval_observer
+//
+//  Abstract base class for fixed-point value type observers;
+//  arbitrary precision.
+// ----------------------------------------------------------------------------
+
+sc_fxval_observer *(* sc_fxval_observer::default_observer)() = 0;
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_fxval_fast_observer
+//
+//  Abstract base class for fixed-point value type observers;
+//  limited precision.
+// ----------------------------------------------------------------------------
+
+sc_fxval_fast_observer *(* sc_fxval_fast_observer::default_observer)() = 0;
+
+} // namespace sc_dt
diff --git a/src/systemc/dt/fx/scfx_mant.cc b/src/systemc/dt/fx/scfx_mant.cc
new file mode 100644
index 0000000..41f3aed
--- /dev/null
+++ b/src/systemc/dt/fx/scfx_mant.cc
@@ -0,0 +1,117 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  scfx_mant.cpp -
+
+  Original Author: Robert Graulich, Synopsys, Inc.
+                   Martin Janssen,  Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: scfx_mant.cpp,v $
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:58  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#include "systemc/ext/dt/fx/scfx_mant.hh"
+
+namespace sc_dt
+{
+
+// ----------------------------------------------------------------------------
+//  word memory management
+// ----------------------------------------------------------------------------
+
+class word_list // Entry in free_words bucket.
+{
+  public:
+    word_list *m_next_p;
+};
+
+static inline unsigned
+next_pow2_index(std::size_t size)
+{
+    unsigned index = scfx_find_msb(size);
+    // If this was a power of 2 we are one bucket too low.
+    if (~(UINT64_ONE << index) & size)
+        index++;
+    // If this is a 64-bit machine and we are using 32-bit words go down
+    // one slot size, as all the slots are 2x in size.
+    if (index != 0 && (sizeof(word_list) != sizeof(word))) {
+        index -= 1;
+    }
+    return index;
+}
+
+static word_list *free_words[32] = { 0 };
+
+word *
+scfx_mant::alloc_word(std::size_t size)
+{
+    const int ALLOC_SIZE = 128;
+
+    unsigned slot_index = next_pow2_index(size);
+    unsigned alloc_size = (UINT64_ONE << slot_index);
+
+    word_list*& slot = free_words[slot_index];
+
+    if (!slot) {
+        slot = new word_list[ALLOC_SIZE * alloc_size];
+        unsigned i;
+        for (i = 0; i < alloc_size * (ALLOC_SIZE - 1) ; i += alloc_size) {
+            slot[i].m_next_p = &slot[i + alloc_size];
+        }
+        slot[i].m_next_p = 0;
+    }
+
+    word *result = (word *)slot;
+    free_words[slot_index] = slot[0].m_next_p;
+    return result;
+}
+
+void
+scfx_mant::free_word(word *array, std::size_t size)
+{
+    if (array && size) {
+        int slot_index = next_pow2_index(size);
+        word_list *wl_p = (word_list *)array;
+
+        wl_p->m_next_p = free_words[slot_index];
+        free_words[slot_index] = wl_p;
+    }
+}
+
+} // namespace sc_dt
diff --git a/src/systemc/dt/fx/scfx_pow10.cc b/src/systemc/dt/fx/scfx_pow10.cc
new file mode 100644
index 0000000..fd940f9
--- /dev/null
+++ b/src/systemc/dt/fx/scfx_pow10.cc
@@ -0,0 +1,129 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  scfx_pow10.cpp -
+
+  Original Author: Robert Graulich, Synopsys, Inc.
+                   Martin Janssen,  Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: scfx_pow10.cpp,v $
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:58  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#include "systemc/ext/dt/fx/scfx_pow10.hh"
+
+namespace sc_dt
+{
+
+// ----------------------------------------------------------------------------
+//  CLASS : scfx_pow10
+//
+//  Class to compute (and cache) powers of 10 in arbitrary precision.
+// ----------------------------------------------------------------------------
+
+scfx_pow10::scfx_pow10()
+{
+    m_pos[0] = scfx_rep(10.0);
+    m_neg[0] = scfx_rep(0.1);
+
+    for (int i = 1; i < SCFX_POW10_TABLE_SIZE; i++) {
+        m_pos[i].set_nan();
+        m_neg[i].set_nan();
+    }
+}
+
+scfx_pow10::~scfx_pow10() {}
+
+const scfx_rep
+scfx_pow10::operator() (int i)
+{
+    if (i == 0) {
+        return scfx_rep(1.0);
+    }
+
+    if (i > 0) {
+        int bit = scfx_find_msb(i);
+        scfx_rep result = *pos(bit);
+        if (bit) {
+            while (--bit >= 0) {
+                if ((1 << bit) & i) {
+                    scfx_rep *tmp = mult_scfx_rep(result, *pos(bit));
+                    result = *tmp;
+                    delete tmp;
+                }
+            }
+        }
+        return result;
+    } else {
+        i = -i;
+        int bit = scfx_find_msb(i);
+        scfx_rep result = *neg(bit);
+        if (bit) {
+            while (--bit >= 0) {
+                if ((1 << bit) & i) {
+                    scfx_rep *tmp = mult_scfx_rep(result, *neg(bit));
+                    result = *tmp;
+                    delete tmp;
+                }
+            }
+        }
+        return result;
+    }
+}
+
+
+scfx_rep *
+scfx_pow10::pos(int i)
+{
+    if (!m_pos[i].is_normal()) {
+        multiply(m_pos[i], *pos(i - 1), *pos(i - 1));
+    }
+    return &m_pos[i];
+}
+
+scfx_rep *
+scfx_pow10::neg(int i)
+{
+    if (!m_neg[i].is_normal()) {
+        multiply(m_neg[i], *neg(i - 1), *neg(i - 1));
+    }
+    return &m_neg[i];
+}
+
+} // namespace sc_dt
diff --git a/src/systemc/dt/fx/scfx_rep.cc b/src/systemc/dt/fx/scfx_rep.cc
new file mode 100644
index 0000000..3d10fb3
--- /dev/null
+++ b/src/systemc/dt/fx/scfx_rep.cc
@@ -0,0 +1,2651 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  scfx_rep.cpp -
+
+  Original Author: Robert Graulich, Synopsys, Inc.
+                   Martin Janssen,  Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: scfx_rep.cpp,v $
+// Revision 1.4  2011/08/24 22:05:43  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.3  2011/08/15 16:43:24  acg
+//  Torsten Maehne: changes to remove unused argument warnings.
+//
+// Revision 1.2  2009/02/28 00:26:20  acg
+//  Andy Goodrich: bug fixes.
+//
+// Revision 1.2  2008/11/06 17:22:47  acg
+//  Andy Goodrich: bug fixes for 2.2.1.
+//
+// Revision 1.1.1.1  2006/12/15 20:31:36  acg
+// SystemC 2.2
+//
+// Revision 1.3  2006/01/13 18:53:58  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#include <cctype>
+#include <cmath>
+#include <cstdio>
+#include <cstdlib>
+
+#include "base/compiler.hh"
+#include "systemc/ext/dt/bit/sc_bv_base.hh"
+#include "systemc/ext/dt/bit/sc_lv_base.hh"
+#include "systemc/ext/dt/fx/scfx_ieee.hh"
+#include "systemc/ext/dt/fx/scfx_pow10.hh"
+#include "systemc/ext/dt/fx/scfx_rep.hh"
+#include "systemc/ext/dt/fx/scfx_utils.hh"
+#include "systemc/ext/utils/endian.hh"
+
+namespace sc_dt
+{
+
+// ----------------------------------------------------------------------------
+//  some utilities
+// ----------------------------------------------------------------------------
+
+static scfx_pow10 pow10_fx;
+
+static const int mantissa0_size = SCFX_IEEE_DOUBLE_M_SIZE - bits_in_int;
+
+static inline int
+n_word(int x)
+{
+    return (x + bits_in_word - 1) / bits_in_word;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CONSTRUCTORS
+// ----------------------------------------------------------------------------
+
+scfx_rep::scfx_rep() :
+    m_mant(min_mant), m_wp(), m_sign(), m_state(), m_msw(), m_lsw(),
+    m_r_flag(false)
+{
+    set_zero();
+}
+
+scfx_rep::scfx_rep(int a) : m_mant(min_mant), m_wp(), m_sign(), m_state(),
+    m_msw(), m_lsw(), m_r_flag(false)
+{
+    if (a != 0) {
+        m_mant.clear();
+        m_wp = m_msw = m_lsw = 2;
+        m_state = normal;
+        if (a > 0) {
+            m_mant[2] = a;
+            m_sign = 1;
+        } else {
+            m_mant[2] = -a;
+            m_sign = -1;
+        }
+    } else {
+        set_zero();
+    }
+}
+
+scfx_rep::scfx_rep(unsigned int a) : m_mant(min_mant), m_wp(), m_sign(),
+    m_state(), m_msw(), m_lsw(), m_r_flag(false)
+{
+    if (a != 0) {
+        m_mant.clear();
+        m_wp = m_msw = m_lsw = 2;
+        m_state = normal;
+        m_mant[2] = a;
+        m_sign = 1;
+    } else {
+        set_zero();
+    }
+}
+
+scfx_rep::scfx_rep(long a) :
+    m_mant(min_mant), m_wp(), m_sign(), m_state(), m_msw(), m_lsw(),
+    m_r_flag(false)
+{
+    if (a != 0) {
+        m_mant.clear();
+        m_state = normal;
+        if (a > 0) {
+            m_sign = 1;
+        } else {
+            a = -a;
+            m_sign = -1;
+        }
+#       if defined(SC_LONG_64)
+            m_wp = 1;
+            m_mant[1] = static_cast<word>(a);
+            m_mant[2] = static_cast<word>(a >> bits_in_word);
+            find_sw();
+#       else
+            m_wp = 2;
+            m_msw = 2;
+            m_lsw = 2;
+            m_mant[2] = a;
+#       endif
+    } else {
+        set_zero();
+    }
+}
+
+scfx_rep::scfx_rep(unsigned long a) :
+    m_mant(min_mant), m_wp(), m_sign(), m_state(), m_msw(), m_lsw(),
+    m_r_flag(false)
+{
+    if (a != 0) {
+        m_mant.clear();
+        m_wp = m_msw = m_lsw = 2;
+        m_state = normal;
+#       if defined(SC_LONG_64)
+            m_wp = 1;
+            m_mant[1] = static_cast<word>(a);
+            m_mant[2] = static_cast<word>(a >> bits_in_word);
+            find_sw();
+#       else
+            m_wp = 2;
+            m_msw = 2;
+            m_lsw = 2;
+            m_mant[2] = a;
+#       endif
+        m_sign = 1;
+    }
+    else
+        set_zero();
+}
+
+scfx_rep::scfx_rep(double a) :
+    m_mant(min_mant), m_wp(0), m_sign(), m_state(normal), m_msw(0),
+    m_lsw(0), m_r_flag(false)
+{
+    m_mant.clear();
+
+    scfx_ieee_double id(a);
+
+    m_sign = id.negative() ? -1 : 1;
+
+    if (id.is_nan()) {
+        m_state = not_a_number;
+    } else if (id.is_inf()) {
+        m_state = infinity;
+    } else if (id.is_subnormal()) {
+        m_mant[0] = id.mantissa1();
+        m_mant[1] = id.mantissa0();
+        normalize(id.exponent() + 1 - SCFX_IEEE_DOUBLE_M_SIZE);
+    } else if (id.is_normal()) {
+        m_mant[0] = id.mantissa1();
+        m_mant[1] = id.mantissa0() | (1 << mantissa0_size);
+        normalize(id.exponent() - SCFX_IEEE_DOUBLE_M_SIZE);
+    }
+}
+
+scfx_rep::scfx_rep(int64 a) :
+    m_mant(min_mant), m_wp(), m_sign(), m_state(), m_msw(), m_lsw(),
+    m_r_flag(false)
+{
+    if (a != 0) {
+        m_mant.clear();
+        m_wp = 1;
+        m_state = normal;
+        if (a > 0) {
+            m_mant[1] = static_cast<word>(a);
+            m_mant[2] = static_cast<word>(a >> bits_in_word);
+            m_sign = 1;
+        } else {
+            m_mant[1] = static_cast<word>(-a);
+            m_mant[2] = static_cast<word>((-a) >> bits_in_word);
+            m_sign = -1;
+        }
+        find_sw();
+    } else {
+        set_zero();
+    }
+}
+
+scfx_rep::scfx_rep(uint64 a) :
+    m_mant(min_mant), m_wp(), m_sign(), m_state(), m_msw(), m_lsw(),
+    m_r_flag(false)
+{
+    if (a != 0) {
+        m_mant.clear();
+        m_wp = 1;
+        m_state = normal;
+        m_mant[1] = static_cast<word>(a);
+        m_mant[2] = static_cast<word>(a >> bits_in_word);
+        m_sign = 1;
+        find_sw();
+    } else {
+        set_zero();
+    }
+}
+
+scfx_rep::scfx_rep(const sc_signed &a) :
+    m_mant(min_mant), m_wp(), m_sign(), m_state(), m_msw(), m_lsw(),
+    m_r_flag(false)
+{
+    if (a.iszero()) {
+        set_zero();
+    } else {
+        int words = n_word(a.length());
+        if (words > size())
+            resize_to(words);
+        m_mant.clear();
+        m_wp = 0;
+        m_state = normal;
+        if (a.sign()) {
+            sc_signed a2 = -a;
+            for (int i = 0; i < a2.length(); ++i) {
+                if (a2[i]) {
+                    scfx_index x = calc_indices(i);
+                    m_mant[x.wi()] |= 1 << x.bi();
+                }
+            }
+            m_sign = -1;
+        } else {
+            for (int i = 0; i < a.length(); ++i) {
+                if (a[i]) {
+                    scfx_index x = calc_indices(i);
+                    m_mant[x.wi()] |= 1 << x.bi();
+                }
+            }
+            m_sign = 1;
+        }
+        find_sw();
+    }
+}
+
+scfx_rep::scfx_rep(const sc_unsigned &a) :
+    m_mant(min_mant), m_wp(), m_sign(), m_state(), m_msw(), m_lsw(),
+    m_r_flag(false)
+{
+    if (a.iszero()) {
+        set_zero();
+    } else {
+        int words = n_word(a.length());
+        if (words > size())
+            resize_to(words);
+        m_mant.clear();
+        m_wp = 0;
+        m_state = normal;
+        for (int i = 0; i < a.length(); ++i) {
+            if (a[i]) {
+                scfx_index x = calc_indices(i);
+                m_mant[x.wi()] |= 1 << x.bi();
+            }
+        }
+        m_sign = 1;
+        find_sw();
+    }
+}
+
+// copy constructor
+scfx_rep::scfx_rep(const scfx_rep &a) :
+    m_mant(a.m_mant), m_wp(a.m_wp), m_sign(a.m_sign), m_state(a.m_state),
+    m_msw(a.m_msw), m_lsw(a.m_lsw), m_r_flag(false)
+{}
+
+
+// ----------------------------------------------------------------------------
+//  OPERATORS : new, delete
+//
+//  Memory management for class scfx_rep.
+// ----------------------------------------------------------------------------
+
+union scfx_rep_node
+{
+    char data[sizeof(scfx_rep)];
+    scfx_rep_node *next;
+};
+
+static scfx_rep_node *list = 0;
+
+void *
+scfx_rep::operator new(std::size_t size)
+{
+    const int ALLOC_SIZE = 1024;
+
+    if (size != sizeof(scfx_rep))
+        return ::operator new(size);
+
+    if (!list) {
+        list = new scfx_rep_node[ALLOC_SIZE];
+        for (int i = 0; i < ALLOC_SIZE - 1; i++)
+            list[i].next = list + i + 1;
+        list[ALLOC_SIZE - 1].next = 0;
+    }
+
+    scfx_rep *ptr = reinterpret_cast<scfx_rep *>(list->data);
+    list = list->next;
+
+    return ptr;
+}
+
+void
+scfx_rep::operator delete(void *ptr, std::size_t size)
+{
+    if (size != sizeof(scfx_rep)) {
+        ::operator delete(ptr);
+        return;
+    }
+
+    scfx_rep_node *node = static_cast<scfx_rep_node *>(ptr);
+    node->next = list;
+    list = node;
+}
+
+
+// ----------------------------------------------------------------------------
+//  METHOD : from_string
+//
+//  Convert from character string to sc_fxrep.
+// ----------------------------------------------------------------------------
+
+#define SCFX_FAIL_IF_(cnd) \
+{ \
+    if ((cnd)) { \
+        m_state = not_a_number; \
+        m_mant.clear(); /* to avoid Purify UMRs during assignment */ \
+        return; \
+    } \
+}
+
+void
+scfx_rep::from_string(const char *s, int cte_wl)
+{
+    SCFX_FAIL_IF_(s == 0 || *s == 0);
+
+    scfx_string s2;
+    s2 += s;
+    s2 += '\0';
+
+    bool sign_char;
+    m_sign = scfx_parse_sign(s, sign_char);
+
+    sc_numrep numrep = scfx_parse_prefix(s);
+
+    int base = 0;
+
+    switch (numrep) {
+      case SC_DEC:
+        {
+            base = 10;
+            if (scfx_is_nan(s)) {   // special case: NaN
+                m_state = not_a_number;
+                m_mant.clear(); /* to avoid Purify UMRs during assignment */
+                return;
+            }
+            if (scfx_is_inf(s)) {   // special case: Infinity
+                m_state = infinity;
+                m_mant.clear(); /* to avoid Purify UMRs during assignment */
+                return;
+            }
+            break;
+        }
+      case SC_BIN:
+      case SC_BIN_US:
+        {
+            SCFX_FAIL_IF_(sign_char);
+            base = 2;
+            break;
+        }
+
+      case SC_BIN_SM:
+        {
+            base = 2;
+            break;
+        }
+      case SC_OCT:
+      case SC_OCT_US:
+        {
+            SCFX_FAIL_IF_(sign_char);
+            base = 8;
+            break;
+        }
+      case SC_OCT_SM:
+        {
+            base = 8;
+            break;
+        }
+      case SC_HEX:
+      case SC_HEX_US:
+        {
+            SCFX_FAIL_IF_(sign_char);
+            base = 16;
+            break;
+        }
+      case SC_HEX_SM:
+        {
+            base = 16;
+            break;
+        }
+      case SC_CSD:
+        {
+            SCFX_FAIL_IF_(sign_char);
+            base = 2;
+            scfx_csd2tc(s2);
+            s = (const char *)s2 + 4;
+            numrep = SC_BIN;
+            break;
+        }
+      default:
+        ;
+    }
+
+    //
+    // find end of mantissa and count the digits and points
+    //
+
+    const char *end = s;
+    bool based_point = false;
+    int int_digits = 0;
+    int frac_digits = 0;
+
+    while (*end) {
+        if (scfx_exp_start(end))
+            break;
+
+        if (*end == '.') {
+            SCFX_FAIL_IF_(based_point);
+            based_point = true;
+        } else {
+            SCFX_FAIL_IF_(!scfx_is_digit(*end, numrep));
+            if (based_point)
+                frac_digits++;
+            else
+                int_digits++;
+        }
+
+        ++end;
+    }
+
+    SCFX_FAIL_IF_(int_digits == 0 && frac_digits == 0);
+
+    // [ exponent ]
+    int exponent = 0;
+
+    if (*end) {
+        for (const char *e = end + 2; *e; ++e)
+            SCFX_FAIL_IF_(!scfx_is_digit(*e, SC_DEC));
+        exponent = std::atoi(end + 1);
+    }
+
+    //
+    // check if the mantissa is negative
+    //
+    bool mant_is_neg = false;
+    switch (numrep) {
+      case SC_BIN:
+      case SC_OCT:
+      case SC_HEX:
+        {
+            const char *p = s;
+            if (*p == '.')
+                ++p;
+
+            mant_is_neg = (scfx_to_digit(* p, numrep) >= (base >> 1));
+            break;
+        }
+      default:
+            ;
+    }
+
+    //
+    // convert the mantissa
+    //
+
+    switch (base) {
+      case 2:
+        {
+            int bit_offset = exponent % bits_in_word;
+            int word_offset = exponent / bits_in_word;
+
+            int_digits += bit_offset;
+            frac_digits -= bit_offset;
+
+            int words = n_word(int_digits) + n_word(frac_digits);
+            if (words > size())
+                resize_to(words);
+            m_mant.clear();
+
+            int j = n_word(frac_digits) * bits_in_word + int_digits - 1;
+
+            for (; s < end; s++) {
+                switch (*s) {
+                  case '1':
+                    set_bin(j);
+                    M5_FALLTHROUGH;
+                  case '0':
+                    j--;
+                    M5_FALLTHROUGH;
+                  case '.':
+                    break;
+                  default:
+                    SCFX_FAIL_IF_(true); // should not happen
+                }
+            }
+
+            m_wp = n_word(frac_digits) - word_offset;
+            break;
+        }
+      case 8:
+        {
+            exponent *= 3;
+            int_digits *= 3;
+            frac_digits *= 3;
+
+            int bit_offset = exponent % bits_in_word;
+            int word_offset = exponent / bits_in_word;
+
+            int_digits += bit_offset;
+            frac_digits -= bit_offset;
+
+            int words = n_word(int_digits) + n_word(frac_digits);
+            if (words > size())
+                resize_to(words);
+            m_mant.clear();
+
+            int j = n_word(frac_digits) * bits_in_word + int_digits - 3;
+
+            for (; s < end; s++) {
+                switch (*s) {
+                  case '7': case '6': case '5': case '4':
+                  case '3': case '2': case '1':
+                    set_oct(j, *s - '0');
+                    M5_FALLTHROUGH;
+                  case '0':
+                    j -= 3;
+                    M5_FALLTHROUGH;
+                  case '.':
+                    break;
+                  default:
+                    SCFX_FAIL_IF_(true); // should not happen
+                }
+            }
+
+            m_wp = n_word(frac_digits) - word_offset;
+            break;
+        }
+      case 10:
+        {
+            word carry, temp;
+            int length = int_digits + frac_digits;
+            resize_to(sc_max(min_mant, n_word(4 * length)));
+
+            m_mant.clear();
+            m_msw = m_lsw = 0;
+
+            for (; s < end; s++) {
+                switch (*s) {
+                  case '9': case '8': case '7': case '6': case '5':
+                  case '4': case '3': case '2': case '1': case '0':
+                    multiply_by_ten();
+                    carry = *s - '0';
+                    for (int i = 0; carry && i < m_mant.size(); i++) {
+                        temp = m_mant[i];
+                        temp += carry;
+                        carry = temp < m_mant[i];
+                        m_mant[i] = temp;
+                    }
+                  case '.':
+                    break;
+                  default:
+                    SCFX_FAIL_IF_(true); // should not happen
+                }
+            }
+
+            m_wp = 0;
+            find_sw();
+
+            int denominator = frac_digits - exponent;
+
+            if (denominator) {
+                scfx_rep frac_num = pow10_fx(denominator);
+                scfx_rep *temp_num =
+                    div_scfx_rep(const_cast<const scfx_rep &>(*this),
+                                   frac_num, cte_wl);
+                *this = *temp_num;
+                delete temp_num;
+            }
+
+            break;
+        }
+      case 16:
+        {
+            exponent *= 4;
+            int_digits *= 4;
+            frac_digits *= 4;
+
+            int bit_offset = exponent % bits_in_word;
+            int word_offset = exponent / bits_in_word;
+
+            int_digits += bit_offset;
+            frac_digits -= bit_offset;
+
+            int words = n_word(int_digits) + n_word(frac_digits);
+            if (words > size())
+                resize_to(words);
+            m_mant.clear();
+
+            int j = n_word(frac_digits) * bits_in_word + int_digits - 4;
+
+            for (; s < end; s ++) {
+                switch (*s) {
+                  case 'f': case 'e': case 'd': case 'c': case 'b': case 'a':
+                    set_hex(j, *s - 'a' + 10);
+                    j -= 4;
+                    break;
+                  case 'F': case 'E': case 'D': case 'C': case 'B': case 'A':
+                    set_hex(j, *s - 'A' + 10);
+                    j -= 4;
+                    break;
+                  case '9': case '8': case '7': case '6': case '5':
+                  case '4': case '3': case '2': case '1':
+                    set_hex(j, *s - '0');
+                    M5_FALLTHROUGH;
+                  case '0':
+                    j -= 4;
+                    M5_FALLTHROUGH;
+                  case '.':
+                    break;
+                  default:
+                    SCFX_FAIL_IF_(true); // should not happen
+                }
+            }
+
+            m_wp = n_word(frac_digits) - word_offset;
+            break;
+        }
+    }
+
+    m_state = normal;
+    find_sw();
+
+    //
+    // two's complement of mantissa if it is negative
+    //
+    if (mant_is_neg) {
+        m_mant[m_msw] |=  ~0U << scfx_find_msb(m_mant[m_msw]);
+        for (int i = m_msw + 1; i < m_mant.size(); ++i)
+            m_mant[i] = static_cast<word>(-1);
+        complement(m_mant, m_mant, m_mant.size());
+        inc(m_mant);
+        m_sign *= -1;
+        find_sw();
+    }
+}
+
+#undef SCFX_FAIL_IF_
+
+// ----------------------------------------------------------------------------
+//  METHOD : to_double
+//
+//  Convert from scfx_rep to double.
+// ----------------------------------------------------------------------------
+
+double
+scfx_rep::to_double() const
+{
+    scfx_ieee_double id;
+
+    // handle special cases
+    if (is_nan()) {
+        id.set_nan();
+        return id;
+    }
+
+    if (is_inf()) {
+        id.set_inf();
+        id.negative(m_sign < 0);
+        return id;
+    }
+
+    if (is_zero()) {
+        id = 0.;
+        id.negative(m_sign < 0);
+        return id;
+    }
+
+    int msb = scfx_find_msb(m_mant[m_msw]);
+
+    int exp = (m_msw - m_wp) * bits_in_word + msb;
+
+    if (exp > SCFX_IEEE_DOUBLE_E_MAX) {
+        id.set_inf();
+        id.negative(m_sign < 0);
+        return id;
+    }
+
+    if (exp < SCFX_IEEE_DOUBLE_E_MIN -
+        static_cast<int>(SCFX_IEEE_DOUBLE_M_SIZE))
+    {
+        id = 0.;
+        return id;
+    }
+
+    int shift = mantissa0_size - msb;
+
+    unsigned int m0;
+    unsigned int m1 = 0;
+    unsigned int guard = 0;
+
+    if (shift == 0) {
+        m0 = m_mant[m_msw] & ~(1 << mantissa0_size);
+        if (m_msw > m_lsw) {
+            m1 = m_mant[m_msw - 1];
+            if (m_msw - 1 > m_lsw)
+                guard = m_mant[m_msw - 2] >> (bits_in_word - 1);
+        }
+    } else if (shift < 0) {
+        m0 = (m_mant[m_msw] >> -shift) & ~(1 << mantissa0_size);
+        m1 = m_mant[m_msw] << (bits_in_word + shift);
+        if (m_msw > m_lsw) {
+            m1 |= m_mant[m_msw - 1] >> -shift;
+            guard = (m_mant[m_msw - 1] >> (-shift - 1)) & 1;
+        }
+    } else {
+        m0 = (m_mant[m_msw] << shift) & ~(1 << mantissa0_size);
+        if (m_msw > m_lsw) {
+            m0 |= m_mant[m_msw - 1] >> (bits_in_word - shift);
+            m1 = m_mant[m_msw - 1] << shift;
+            if (m_msw - 1 > m_lsw) {
+                m1 |= m_mant[m_msw - 2] >> (bits_in_word - shift);
+                guard = (m_mant[m_msw - 2] >> (bits_in_word - shift - 1)) & 1;
+            }
+        }
+    }
+
+    if (exp < SCFX_IEEE_DOUBLE_E_MIN) {
+        m0 |= (1 << mantissa0_size);
+
+        int subnormal_shift = SCFX_IEEE_DOUBLE_E_MIN - exp;
+
+        if (subnormal_shift < bits_in_word) {
+            m1 = m1 >> subnormal_shift |
+                m0 << (bits_in_word - subnormal_shift);
+            m0 = m0 >> subnormal_shift;
+        } else {
+            m1 = m0 >> (subnormal_shift - bits_in_word);
+            m0 = 0;
+        }
+
+        guard = 0;
+
+        exp = SCFX_IEEE_DOUBLE_E_MIN - 1;
+    }
+
+    id.mantissa0(m0);
+    id.mantissa1(m1);
+    id.exponent(exp);
+    id.negative(m_sign < 0);
+
+    double result = id;
+
+    if (guard != 0)
+        result += m_sign * scfx_pow2(exp - SCFX_IEEE_DOUBLE_M_SIZE);
+
+    return result;
+}
+
+
+// ----------------------------------------------------------------------------
+//  METHOD : to_uint64
+//
+//  Convert from scfx_rep to uint64.
+//  Truncates towards 0 _then_ wraps; infinities and NaN go to zero.
+// ----------------------------------------------------------------------------
+
+uint64
+scfx_rep::to_uint64() const
+{
+    if (!is_normal() || is_zero()) {
+        return 0;
+    }
+
+    uint64 result = 0;
+    int shift = 0;
+    int idx = m_wp;
+
+    // Ignore bits off the top; they modulo out.
+    // Ignore bits off the bottom; we're truncating.
+    while (shift < 64 && m_msw >= idx && idx >= m_lsw) {
+        result += static_cast<uint64>(m_mant[idx]) << shift;
+        shift += bits_in_word;
+        idx += 1;
+    }
+
+    return m_sign > 0 ? result : -result;
+}
+
+
+// ----------------------------------------------------------------------------
+//  METHOD : to_string
+//
+//  Convert from scfx_rep to character string.
+// ----------------------------------------------------------------------------
+
+void
+print_dec(scfx_string &s, const scfx_rep &num, int w_prefix, sc_fmt fmt)
+{
+    if (num.is_neg())
+        s += '-';
+
+    if (w_prefix == 1) {
+        scfx_print_prefix(s, SC_DEC);
+    }
+
+    if (num.is_zero()) {
+        s += '0';
+        return;
+    }
+
+    // split 'num' into its integer and fractional part
+    scfx_rep int_part = num;
+    scfx_rep frac_part = num;
+
+    int i;
+
+    for (i = int_part.m_lsw; i <= int_part.m_msw && i < int_part.m_wp; i++)
+        int_part.m_mant[i] = 0;
+    int_part.find_sw();
+    if (int_part.m_wp < int_part.m_lsw)
+        int_part.resize_to(int_part.size() - int_part.m_wp, -1);
+
+    for (i = frac_part.m_msw;
+            i >= frac_part.m_lsw && i >= frac_part.m_wp; i--)
+        frac_part.m_mant[i] = 0;
+    frac_part.find_sw();
+    if (frac_part.m_msw == frac_part.size() - 1)
+        frac_part.resize_to(frac_part.size() + 1, 1);
+
+    // print integer part
+    int int_digits = 0;
+    int int_zeros  = 0;
+
+    if (!int_part.is_zero()) {
+        double int_wl = (int_part.m_msw - int_part.m_wp) * bits_in_word +
+                         scfx_find_msb(int_part.m_mant[int_part.m_msw]) + 1;
+        int_digits = (int)std::ceil(int_wl * std::log10(2.));
+
+        int len = s.length();
+        s.append(int_digits);
+
+        bool zero_digits = (frac_part.is_zero() && fmt != SC_F);
+
+        for (i = int_digits + len - 1; i >= len; i--) {
+            unsigned int remainder = int_part.divide_by_ten();
+            s[i] = static_cast<char>('0' + remainder);
+
+            if (zero_digits) {
+                if (remainder == 0)
+                    int_zeros++;
+                else
+                    zero_digits = false;
+            }
+        }
+
+        // discard trailing zeros from int_part
+        s.discard(int_zeros);
+
+        if (s[len] == '0') {
+            // int_digits was overestimated by one
+            s.remove(len);
+            --int_digits;
+        }
+    }
+
+    // print fractional part
+    int frac_digits = 0;
+    int frac_zeros  = 0;
+
+    if (!frac_part.is_zero()) {
+        s += '.';
+
+        bool zero_digits = (int_digits == 0 && fmt != SC_F);
+
+        double frac_wl = (frac_part.m_wp - frac_part.m_msw) * bits_in_word -
+                          scfx_find_msb(frac_part.m_mant[frac_part.m_msw]) - 1;
+        frac_zeros = (int)std::floor(frac_wl * std::log10(2.));
+
+        scfx_rep temp;
+        sc_dt::multiply(temp, frac_part, pow10_fx(frac_zeros));
+        frac_part = temp;
+        if (frac_part.m_msw == frac_part.size() - 1)
+            frac_part.resize_to(frac_part.size() + 1, 1);
+
+        frac_digits = frac_zeros;
+        if (!zero_digits) {
+            for (i = 0; i < frac_zeros; i++)
+                s += '0';
+            frac_zeros = 0;
+        }
+
+        while (!frac_part.is_zero()) {
+            frac_part.multiply_by_ten();
+            int n = frac_part.m_mant[frac_part.m_msw + 1];
+
+            if (zero_digits) {
+                if (n == 0)
+                    frac_zeros++;
+                else
+                    zero_digits = false;
+            }
+
+            if (! zero_digits)
+                s += static_cast<char>('0' + n);
+
+            frac_part.m_mant[frac_part.m_msw + 1] = 0;
+            frac_digits++;
+        }
+    }
+
+    // print exponent
+    if (fmt != SC_F) {
+        if (frac_digits == 0)
+            scfx_print_exp(s, int_zeros);
+        else if (int_digits == 0)
+            scfx_print_exp(s, -frac_zeros);
+    }
+}
+
+void
+print_other(scfx_string &s, const scfx_rep &a, sc_numrep numrep, int w_prefix,
+            sc_fmt fmt, const scfx_params *params)
+{
+    scfx_rep b = a;
+
+    sc_numrep numrep2 = numrep;
+
+    bool numrep_is_sm = (numrep == SC_BIN_SM ||
+                         numrep == SC_OCT_SM ||
+                         numrep == SC_HEX_SM);
+
+    if (numrep_is_sm) {
+        if (b.is_neg()) {
+            s += '-';
+            b = *neg_scfx_rep(a);
+        }
+        switch (numrep) {
+          case SC_BIN_SM:
+            numrep2 = SC_BIN_US;
+            break;
+          case SC_OCT_SM:
+            numrep2 = SC_OCT_US;
+            break;
+          case SC_HEX_SM:
+            numrep2 = SC_HEX_US;
+            break;
+          default:
+            ;
+        }
+    }
+
+    if (w_prefix != 0) {
+        scfx_print_prefix(s, numrep);
+    }
+
+    numrep = numrep2;
+
+    int msb, lsb;
+
+    if (params != 0) {
+        msb = params->iwl() - 1;
+        lsb = params->iwl() - params->wl();
+
+        if (params->enc() == SC_TC_ &&
+            (numrep == SC_BIN_US ||
+              numrep == SC_OCT_US ||
+              numrep == SC_HEX_US) &&
+            !numrep_is_sm &&
+            params->wl() > 1) {
+            --msb;
+        } else if (params->enc() == SC_US_ &&
+            (numrep == SC_BIN ||
+              numrep == SC_OCT ||
+              numrep == SC_HEX ||
+              numrep == SC_CSD)) {
+            ++msb;
+        }
+    } else {
+        if (b.is_zero()) {
+            msb = 0;
+            lsb = 0;
+        } else {
+            msb = (b.m_msw - b.m_wp) * bits_in_word
+                + scfx_find_msb(b.m_mant[ b.m_msw ]) + 1;
+            while (b.get_bit(msb) == b.get_bit(msb - 1))
+                --msb;
+
+            if (numrep == SC_BIN_US ||
+                numrep == SC_OCT_US ||
+                numrep == SC_HEX_US) {
+                --msb;
+            }
+
+            lsb = (b.m_lsw - b.m_wp) * bits_in_word +
+                scfx_find_lsb(b.m_mant[b.m_lsw]);
+        }
+    }
+
+    int step;
+
+    switch (numrep) {
+      case SC_BIN:
+      case SC_BIN_US:
+      case SC_CSD:
+        step = 1;
+       break;
+      case SC_OCT:
+      case SC_OCT_US:
+        step = 3;
+        break;
+      case SC_HEX:
+      case SC_HEX_US:
+        step = 4;
+        break;
+      default:
+        SC_REPORT_FATAL("assertion failed", "unexpected sc_numrep");
+        sc_core::sc_abort();
+    }
+
+    msb = (int)std::ceil(double(msb + 1) / step) * step - 1;
+
+    lsb = (int)std::floor(double(lsb) / step) * step;
+
+    if (msb < 0) {
+        s += '.';
+        if (fmt == SC_F) {
+            int sign = (b.is_neg()) ? (1 << step) - 1 : 0;
+            for (int i = (msb + 1) / step; i < 0; i++) {
+                if (sign < 10)
+                    s += static_cast<char>(sign + '0');
+                else
+                    s += static_cast<char>(sign + 'a' - 10);
+            }
+        }
+    }
+
+    int i = msb;
+    while (i >= lsb) {
+        int value = 0;
+        for (int j = step - 1; j >= 0; --j) {
+            value += static_cast<int>(b.get_bit(i)) << j;
+            --i;
+        }
+        if (value < 10)
+            s += static_cast<char>(value + '0');
+        else
+            s += static_cast<char>(value + 'a' - 10);
+        if (i == -1)
+            s += '.';
+    }
+
+    if (lsb > 0 && fmt == SC_F) {
+        for (int i = lsb / step; i > 0; i--)
+            s += '0';
+    }
+
+    if (s[s.length() - 1] == '.')
+        s.discard(1);
+
+    if (fmt != SC_F) {
+        if (msb < 0)
+            scfx_print_exp(s, (msb + 1) / step);
+        else if (lsb > 0)
+            scfx_print_exp(s, lsb / step);
+    }
+
+    if (numrep == SC_CSD)
+        scfx_tc2csd(s, w_prefix);
+}
+
+const char *
+scfx_rep::to_string(sc_numrep numrep, int w_prefix,
+                    sc_fmt fmt, const scfx_params *params) const
+{
+    static scfx_string s;
+
+    s.clear();
+
+    if (is_nan()) {
+        scfx_print_nan(s);
+    } else if (is_inf()) {
+        scfx_print_inf(s, is_neg());
+    } else if (is_neg() && !is_zero() &&
+               (numrep == SC_BIN_US ||
+                numrep == SC_OCT_US ||
+                numrep == SC_HEX_US)) {
+        s += "negative";
+    } else if (numrep == SC_DEC || numrep == SC_NOBASE) {
+        sc_dt::print_dec(s, *this, w_prefix, fmt);
+    } else {
+        sc_dt::print_other(s, *this, numrep, w_prefix, fmt, params);
+    }
+
+    return s;
+}
+
+
+// ----------------------------------------------------------------------------
+//  ADD
+//
+//  add two mantissas of the same size
+//  result has the same size
+//  returns carry of operation
+// ----------------------------------------------------------------------------
+
+static inline int
+add_mants(int size, scfx_mant &result, const scfx_mant &a, const scfx_mant &b)
+{
+    unsigned int carry = 0;
+
+    int index = 0;
+
+    do {
+        word x = a[index];
+        word y = b[index];
+
+        y += carry;
+        carry = y < carry;
+        y += x;
+        carry += y < x;
+        result[index] = y;
+    } while (++index < size);
+
+    return (carry ? 1 : 0);
+}
+
+static inline int
+sub_mants(int size, scfx_mant &result, const scfx_mant &a, const scfx_mant &b)
+{
+    unsigned carry = 0;
+
+    int index = 0;
+
+    do {
+        word x = a[index];
+        word y = b[index];
+
+        y += carry;
+        carry = y < carry;
+        y = x - y;
+        carry += y > x;
+        result[index] = y;
+    } while (++index < size);
+
+    return (carry ? 1 : 0);
+}
+
+scfx_rep *
+add_scfx_rep(const scfx_rep &lhs, const scfx_rep &rhs, int max_wl)
+{
+    scfx_rep &result = *new scfx_rep;
+
+    //
+    // check for special cases
+    //
+    if (lhs.is_nan() || rhs.is_nan() ||
+        (lhs.is_inf() && rhs.is_inf() && lhs.m_sign != rhs.m_sign)) {
+        result.set_nan();
+        return &result;
+    }
+
+    if (lhs.is_inf()) {
+        result.set_inf(lhs.m_sign);
+        return &result;
+    }
+
+    if (rhs.is_inf()) {
+        result.set_inf(rhs.m_sign);
+        return &result;
+    }
+
+    //
+    // align operands if needed
+    //
+    scfx_mant_ref lhs_mant;
+    scfx_mant_ref rhs_mant;
+
+    int len_mant = lhs.size();
+    int new_wp = lhs.m_wp;
+
+    align(lhs, rhs, new_wp, len_mant, lhs_mant, rhs_mant);
+
+    //
+    // size the result mantissa
+    //
+    result.resize_to(len_mant);
+    result.m_wp = new_wp;
+
+    //
+    // do it
+    //
+    if (lhs.m_sign == rhs.m_sign) {
+        add_mants(len_mant, result.m_mant, lhs_mant, rhs_mant);
+        result.m_sign = lhs.m_sign;
+    } else {
+        int cmp = compare_abs(lhs, rhs);
+
+        if (cmp == 1) {
+            sub_mants(len_mant, result.m_mant, lhs_mant, rhs_mant);
+            result.m_sign = lhs.m_sign;
+        } else if (cmp == -1) {
+            sub_mants(len_mant, result.m_mant, rhs_mant, lhs_mant);
+            result.m_sign = rhs.m_sign;
+        } else {
+            result.m_mant.clear();
+            result.m_sign = 1;
+        }
+    }
+
+    result.find_sw();
+    result.round(max_wl);
+
+    return &result;
+}
+
+
+// ----------------------------------------------------------------------------
+//  SUB
+//
+//  sub two word's of the same size
+//  result has the same size
+//  returns carry of operation
+// ----------------------------------------------------------------------------
+
+static inline int
+sub_with_index(scfx_mant &a, int a_msw, int /*a_lsw*/,
+               const scfx_mant &b, int b_msw, int b_lsw)
+{
+    unsigned carry = 0;
+
+    int size = b_msw - b_lsw;
+    int a_index = a_msw - size;
+    int b_index = b_msw - size;
+
+    do {
+        word x = a[a_index];
+        word y = b[b_index];
+
+        y += carry;
+        carry = y < carry;
+        y = x - y;
+        carry += y > x;
+        a[a_index] = y;
+
+        a_index++;
+        b_index++;
+    } while (size--);
+
+    if (carry) {
+        // special case: a[a_msw + 1] == 1
+        a[a_msw + 1] = 0;
+    }
+
+    return (carry ? 1 : 0);
+}
+
+scfx_rep *
+sub_scfx_rep(const scfx_rep &lhs, const scfx_rep &rhs, int max_wl)
+{
+    scfx_rep &result = *new scfx_rep;
+
+    //
+    // check for special cases
+    //
+    if (lhs.is_nan() || rhs.is_nan() ||
+        (lhs.is_inf() && rhs.is_inf() && lhs.m_sign == rhs.m_sign)) {
+        result.set_nan();
+        return &result;
+    }
+
+    if (lhs.is_inf()) {
+        result.set_inf(lhs.m_sign);
+        return &result;
+    }
+
+    if (rhs.is_inf()) {
+        result.set_inf(-1 * rhs.m_sign);
+        return &result;
+    }
+
+    //
+    // align operands if needed
+    //
+    scfx_mant_ref lhs_mant;
+    scfx_mant_ref rhs_mant;
+
+    int len_mant = lhs.size();
+    int new_wp = lhs.m_wp;
+
+    align(lhs, rhs, new_wp, len_mant, lhs_mant, rhs_mant);
+
+    //
+    // size the result mantissa
+    //
+    result.resize_to(len_mant);
+    result.m_wp = new_wp;
+
+    //
+    // do it
+    //
+    if (lhs.m_sign != rhs.m_sign) {
+        add_mants(len_mant, result.m_mant, lhs_mant, rhs_mant);
+        result.m_sign = lhs.m_sign;
+    } else {
+        int cmp = compare_abs(lhs, rhs);
+
+        if (cmp == 1) {
+            sub_mants(len_mant, result.m_mant, lhs_mant, rhs_mant);
+            result.m_sign = lhs.m_sign;
+        } else if (cmp == -1) {
+            sub_mants(len_mant, result.m_mant, rhs_mant, lhs_mant);
+            result.m_sign = -rhs.m_sign;
+        } else {
+            result.m_mant.clear();
+            result.m_sign = 1;
+        }
+    }
+
+    result.find_sw();
+    result.round(max_wl);
+
+    return &result;
+}
+
+
+// ----------------------------------------------------------------------------
+//  MUL
+// ----------------------------------------------------------------------------
+
+union word_short
+{
+    word l;
+    struct
+    {
+#if defined(SC_BOOST_BIG_ENDIAN)
+        half_word u;
+        half_word l;
+#elif defined(SC_BOOST_LITTLE_ENDIAN)
+        half_word l;
+        half_word u;
+#endif
+    } s;
+};
+
+#if defined(SC_BOOST_BIG_ENDIAN)
+static const int half_word_incr = -1;
+#elif defined(SC_BOOST_LITTLE_ENDIAN)
+static const int half_word_incr = 1;
+#endif
+
+void
+multiply(scfx_rep &result, const scfx_rep &lhs, const scfx_rep &rhs,
+         int max_wl)
+{
+    //
+    // check for special cases
+    //
+    if (lhs.is_nan() || rhs.is_nan() ||
+        (lhs.is_inf() && rhs.is_zero()) ||
+        (lhs.is_zero() && rhs.is_inf())) {
+        result.set_nan();
+        return;
+    }
+
+    if (lhs.is_inf() || rhs.is_inf()) {
+        result.set_inf(lhs.m_sign * rhs.m_sign);
+        return;
+    }
+
+    if (lhs.is_zero() || rhs.is_zero()) {
+        result.set_zero(lhs.m_sign * rhs.m_sign);
+        return;
+    }
+
+    //
+    // do it
+    //
+    int len_lhs = lhs.m_msw - lhs.m_lsw + 1;
+    int len_rhs = rhs.m_msw - rhs.m_lsw + 1;
+
+    int new_size = sc_max(min_mant, len_lhs + len_rhs);
+    int new_wp = (lhs.m_wp - lhs.m_lsw) + (rhs.m_wp - rhs.m_lsw);
+    int new_sign = lhs.m_sign * rhs.m_sign;
+
+    result.resize_to(new_size);
+    result.m_mant.clear();
+    result.m_wp = new_wp;
+    result.m_sign = new_sign;
+    result.m_state = scfx_rep::normal;
+
+    half_word *s1 = lhs.m_mant.half_addr(lhs.m_lsw);
+    half_word *s2 = rhs.m_mant.half_addr(rhs.m_lsw);
+
+    half_word *t = result.m_mant.half_addr();
+
+    len_lhs <<= 1;
+    len_rhs <<= 1;
+
+    int i1, i2;
+
+    for (i1 = 0; i1 * half_word_incr < len_lhs; i1 += half_word_incr) {
+        word_short ls;
+        ls.l = 0;
+
+        half_word v1 = s1[i1];
+
+        for (i2  = 0; i2 * half_word_incr < len_rhs; i2 += half_word_incr) {
+            ls.l  += v1 * s2[i2];
+            ls.s.l = ls.s.u + ((t[i2] += ls.s.l) < ls.s.l);
+            ls.s.u = 0;
+        }
+
+        t[i2] = ls.s.l;
+        t += half_word_incr;
+    }
+
+    result.find_sw();
+    result.round(max_wl);
+}
+
+
+// ----------------------------------------------------------------------------
+//  DIV
+// ----------------------------------------------------------------------------
+
+scfx_rep *
+div_scfx_rep(const scfx_rep &lhs, const scfx_rep &rhs, int div_wl)
+{
+    scfx_rep &result = *new scfx_rep;
+
+    //
+    // check for special cases
+    //
+    if (lhs.is_nan() || rhs.is_nan() || (lhs.is_inf() && rhs.is_inf()) ||
+        (lhs.is_zero() && rhs.is_zero())) {
+        result.set_nan();
+        return &result;
+    }
+
+    if (lhs.is_inf() || rhs.is_zero()) {
+        result.set_inf(lhs.m_sign * rhs.m_sign);
+        return &result;
+    }
+
+    if (lhs.is_zero() || rhs.is_inf()) {
+        result.set_zero(lhs.m_sign * rhs.m_sign);
+        return &result;
+    }
+
+    //
+    // do it
+    //
+
+    // compute one bit more for rounding
+    div_wl++;
+
+    result.resize_to(sc_max(n_word(div_wl) + 1, min_mant));
+    result.m_mant.clear();
+    result.m_sign = lhs.m_sign * rhs.m_sign;
+
+    int msb_lhs = scfx_find_msb(lhs.m_mant[lhs.m_msw]) +
+                  (lhs.m_msw - lhs.m_wp) * bits_in_word;
+    int msb_rhs = scfx_find_msb(rhs.m_mant[rhs.m_msw]) +
+                  (rhs.m_msw - rhs.m_wp) * bits_in_word;
+
+    int msb_res = msb_lhs - msb_rhs;
+    int to_shift = -msb_res % bits_in_word;
+    int result_index;
+
+    int c = (msb_res % bits_in_word >= 0) ? 1 : 0;
+
+    result_index = (result.size() - c) * bits_in_word + msb_res % bits_in_word;
+    result.m_wp = (result.size() - c) - msb_res / bits_in_word;
+
+    scfx_rep remainder = lhs;
+
+    // align msb from remainder to msb from rhs
+    remainder.lshift(to_shift);
+
+    // make sure msw(remainder) < size - 1
+    if (remainder.m_msw == remainder.size() - 1)
+        remainder.resize_to(remainder.size() + 1, 1);
+
+    // make sure msw(remainder) >= msw(rhs)!
+    int msw_diff = rhs.m_msw - remainder.m_msw;
+    if (msw_diff > 0)
+        remainder.resize_to(remainder.size() + msw_diff, -1);
+
+    int counter;
+
+    for (counter = div_wl; counter && !remainder.is_zero(); counter--) {
+        if (compare_msw_ff(rhs, remainder) <= 0) {
+            result.set_bin(result_index);
+            sub_with_index(remainder.m_mant, remainder.m_msw, remainder.m_lsw,
+                           rhs.m_mant, rhs.m_msw, rhs.m_lsw);
+        }
+        result_index--;
+        remainder.shift_left(1);
+        remainder.m_lsw = remainder.find_lsw();
+    }
+
+    // perform convergent rounding, if needed
+    if (counter == 0) {
+        int index = result_index + 1 - result.m_wp * bits_in_word;
+
+        scfx_index x = result.calc_indices(index);
+        scfx_index x1 = result.calc_indices(index + 1);
+
+        if (result.o_bit_at(x) && result.o_bit_at(x1))
+            result.q_incr(x);
+
+        result.m_r_flag = true;
+    }
+
+    result.find_sw();
+
+    return &result;
+}
+
+// ----------------------------------------------------------------------------
+//  destructive shift mantissa to the left
+// ----------------------------------------------------------------------------
+
+void
+scfx_rep::lshift(int n)
+{
+    if (n == 0)
+        return;
+
+    if (n < 0) {
+        rshift(-n);
+        return;
+    }
+
+    if (is_normal()) {
+        int shift_bits = n % bits_in_word;
+        int shift_words = n / bits_in_word;
+
+        // resize if needed
+        if (m_msw == size() - 1 &&
+            scfx_find_msb(m_mant[m_msw]) >= bits_in_word - shift_bits)
+            resize_to(size() + 1, 1);
+
+        // do it
+        m_wp -= shift_words;
+        shift_left(shift_bits);
+        find_sw();
+    }
+}
+
+// ----------------------------------------------------------------------------
+//  destructive shift mantissa to the right
+// ----------------------------------------------------------------------------
+
+void
+scfx_rep::rshift(int n)
+{
+    if (n == 0)
+        return;
+
+    if (n < 0) {
+        lshift(-n);
+        return;
+    }
+
+    if (is_normal()) {
+        int shift_bits = n % bits_in_word;
+        int shift_words = n / bits_in_word;
+
+        // resize if needed
+        if (m_lsw == 0 && scfx_find_lsb(m_mant[m_lsw]) < shift_bits)
+            resize_to(size() + 1, -1);
+
+        // do it
+        m_wp += shift_words;
+        shift_right(shift_bits);
+        find_sw();
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  FRIEND FUNCTION : compare_abs
+//
+//  Compares the absolute values of two scfx_reps, excluding the special cases.
+// ----------------------------------------------------------------------------
+
+int
+compare_abs(const scfx_rep &a, const scfx_rep &b)
+{
+    // check for zero
+    word a_word = a.m_mant[a.m_msw];
+    word b_word = b.m_mant[b.m_msw];
+
+    if (a_word == 0 || b_word == 0) {
+        if (a_word != 0)
+            return 1;
+        if (b_word != 0)
+            return -1;
+        return 0;
+    }
+
+    // compare msw index
+    int a_msw = a.m_msw - a.m_wp;
+    int b_msw = b.m_msw - b.m_wp;
+
+    if (a_msw > b_msw)
+        return 1;
+
+    if (a_msw < b_msw)
+        return -1;
+
+    // compare content
+    int a_i = a.m_msw;
+    int b_i = b.m_msw;
+
+    while (a_i >= a.m_lsw && b_i >= b.m_lsw) {
+        a_word = a.m_mant[a_i];
+        b_word = b.m_mant[b_i];
+        if (a_word > b_word)
+            return 1;
+        if (a_word < b_word)
+            return -1;
+        --a_i;
+        --b_i;
+    }
+
+    bool a_zero = true;
+    while (a_i >= a.m_lsw) {
+        a_zero = a_zero && (a.m_mant[a_i] == 0);
+        --a_i;
+    }
+
+    bool b_zero = true;
+    while (b_i >= b.m_lsw) {
+        b_zero = b_zero && (b.m_mant[b_i] == 0);
+        --b_i;
+    }
+
+    // assertion: a_zero || b_zero
+
+    if (!a_zero && b_zero)
+        return 1;
+
+    if (a_zero && !b_zero)
+        return -1;
+
+    return 0;
+}
+
+// ----------------------------------------------------------------------------
+//  FRIEND FUNCTION : cmp_scfx_rep
+//
+//  Compares the values of two scfx_reps, including the special cases.
+// ----------------------------------------------------------------------------
+
+int
+cmp_scfx_rep(const scfx_rep &a, const scfx_rep &b)
+{
+    // handle special cases
+
+    if (a.is_nan() || b.is_nan()) {
+        return 2;
+    }
+
+    if (a.is_inf() || b.is_inf()) {
+        if (a.is_inf()) {
+            if (!a.is_neg()) {
+                if (b.is_inf() && !b.is_neg()) {
+                    return 0;
+                } else {
+                    return 1;
+                }
+            } else {
+                if (b.is_inf() && b.is_neg()) {
+                    return 0;
+                } else {
+                    return -1;
+                }
+            }
+        }
+        if (b.is_inf()) {
+            if (!b.is_neg()) {
+                return -1;
+            } else {
+                return 1;
+            }
+        }
+    }
+
+    if (a.is_zero() && b.is_zero()) {
+        return 0;
+    }
+
+    // compare sign
+    if (a.m_sign != b.m_sign) {
+        return a.m_sign;
+    }
+
+    return (a.m_sign * compare_abs(a, b));
+}
+
+
+// ----------------------------------------------------------------------------
+//  PRIVATE METHOD : quantization
+//
+//  Performs destructive quantization.
+// ----------------------------------------------------------------------------
+
+void
+scfx_rep::quantization(const scfx_params &params, bool &q_flag)
+{
+    scfx_index x = calc_indices(params.iwl() - params.wl());
+
+    if (x.wi() < 0)
+        return;
+
+    if (x.wi() >= size())
+        resize_to(x.wi() + 1, 1);
+
+    bool qb = q_bit(x);
+    bool qz = q_zero(x);
+
+    q_flag = (qb || ! qz);
+
+    if (q_flag) {
+        switch (params.q_mode()) {
+          case SC_TRN: // truncation
+            {
+                if (is_neg())
+                    q_incr(x);
+                break;
+            }
+          case SC_RND: // rounding to plus infinity
+            {
+                if (!is_neg()) {
+                    if (qb)
+                        q_incr(x);
+                } else {
+                    if (qb && !qz)
+                        q_incr(x);
+                }
+                break;
+            }
+          case SC_TRN_ZERO: // truncation to zero
+            {
+                break;
+            }
+          case SC_RND_INF: // rounding to infinity
+            {
+                if (qb)
+                    q_incr(x);
+                break;
+            }
+          case SC_RND_CONV: // convergent rounding
+            {
+                if ((qb && !qz) || (qb && qz && q_odd(x)))
+                    q_incr(x);
+                break;
+            }
+          case SC_RND_ZERO: // rounding to zero
+            {
+                if (qb && !qz)
+                    q_incr(x);
+                break;
+            }
+          case SC_RND_MIN_INF: // rounding to minus infinity
+            {
+                if (!is_neg()) {
+                    if (qb && !qz)
+                        q_incr(x);
+                } else {
+                    if (qb)
+                        q_incr(x);
+                }
+                break;
+            }
+          default:
+            ;
+        }
+        q_clear(x);
+
+        find_sw();
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  PRIVATE METHOD : overflow
+//
+//  Performs destructive overflow handling.
+// ----------------------------------------------------------------------------
+
+void
+scfx_rep::overflow(const scfx_params &params, bool &o_flag)
+{
+    scfx_index x = calc_indices(params.iwl() - 1);
+
+    if (x.wi() >= size())
+        resize_to(x.wi() + 1, 1);
+
+    if (x.wi() < 0) {
+        resize_to(size() - x.wi(), -1);
+        x.wi(0);
+    }
+
+    bool zero_left = o_zero_left(x);
+    bool bit_at = o_bit_at(x);
+    bool zero_right = o_zero_right(x);
+
+    bool under = false;
+    bool over = false;
+
+    sc_enc enc = params.enc();
+
+    if (enc == SC_TC_) {
+        if (is_neg()) {
+            if (params.o_mode() == SC_SAT_SYM)
+                under = (!zero_left || bit_at);
+            else
+                under = (!zero_left || (zero_left && bit_at && ! zero_right));
+        } else {
+            over = (! zero_left || bit_at);
+        }
+    } else {
+        if (is_neg())
+            under = (!is_zero());
+        else
+            over = (!zero_left);
+    }
+
+    o_flag = (under || over);
+
+    if (o_flag) {
+        scfx_index x2 = calc_indices(params.iwl() - params.wl());
+
+        if (x2.wi() < 0) {
+            resize_to(size() - x2.wi(), -1);
+            x.wi(x.wi() - x2.wi());
+            x2.wi(0);
+        }
+
+        switch (params.o_mode()) {
+          case SC_WRAP: // wrap-around
+            {
+                int n_bits = params.n_bits();
+
+                if (n_bits == 0) {
+                    // wrap-around all 'wl' bits
+                    toggle_tc();
+                    o_extend(x, enc);
+                    toggle_tc();
+                } else if (n_bits < params.wl()) {
+                    scfx_index x3 = calc_indices(params.iwl() - 1 - n_bits);
+
+                    // wrap-around least significant 'wl - n_bits' bits;
+                    // saturate most significant 'n_bits' bits
+                    toggle_tc();
+                    o_set(x, x3, enc, under);
+                    o_extend(x, enc);
+                    toggle_tc();
+                } else {
+                    // saturate all 'wl' bits
+                    if (under)
+                        o_set_low(x, enc);
+                    else
+                        o_set_high(x, x2, enc);
+                }
+                break;
+            }
+          case SC_SAT: // saturation
+            {
+                if (under)
+                    o_set_low(x, enc);
+                else
+                    o_set_high(x, x2, enc);
+                break;
+            }
+          case SC_SAT_SYM: // symmetrical saturation
+            {
+                if (under) {
+                    if (enc == SC_TC_)
+                        o_set_high(x, x2, SC_TC_, -1);
+                    else
+                        o_set_low(x, SC_US_);
+                } else {
+                    o_set_high(x, x2, enc);
+                }
+                break;
+            }
+          case SC_SAT_ZERO: // saturation to zero
+            {
+                set_zero();
+                break;
+            }
+          case SC_WRAP_SM: // sign magnitude wrap-around
+            {
+                SC_ERROR_IF_(enc == SC_US_,
+                             "SC_WRAP_SM not defined for unsigned numbers");
+
+                int n_bits = params.n_bits();
+
+                if (n_bits == 0) {
+                    scfx_index x4 = calc_indices(params.iwl());
+
+                    if (x4.wi() >= size())
+                        resize_to(x4.wi() + 1, 1);
+
+                    toggle_tc();
+                    if (o_bit_at(x4) != o_bit_at(x))
+                        o_invert(x2);
+                    o_extend(x, SC_TC_);
+                    toggle_tc();
+                } else if (n_bits == 1) {
+                    toggle_tc();
+                    if (is_neg() != o_bit_at(x))
+                        o_invert(x2);
+                    o_extend(x, SC_TC_);
+                    toggle_tc();
+                } else if (n_bits < params.wl()) {
+                    scfx_index x3 = calc_indices(params.iwl() - 1 - n_bits);
+                    scfx_index x4 = calc_indices(params.iwl() - n_bits);
+
+                    // wrap-around least significant 'wl - n_bits' bits;
+                    // saturate most significant 'n_bits' bits
+                    toggle_tc();
+                    if (is_neg() == o_bit_at(x4))
+                        o_invert(x2);
+                    o_set(x, x3, SC_TC_, under);
+                    o_extend(x, SC_TC_);
+                    toggle_tc();
+                } else {
+                    if (under)
+                        o_set_low(x, SC_TC_);
+                    else
+                        o_set_high(x, x2, SC_TC_);
+                }
+                break;
+            }
+          default:
+            ;
+        }
+
+        find_sw();
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  PUBLIC METHOD : cast
+//
+//  Performs a destructive cast operation on a scfx_rep.
+// ----------------------------------------------------------------------------
+
+void
+scfx_rep::cast(const scfx_params &params, bool &q_flag, bool &o_flag)
+{
+    q_flag = false;
+    o_flag = false;
+
+    // check for special cases
+    if (is_zero()) {
+        if (is_neg())
+            m_sign = 1;
+        return;
+    }
+
+    // perform casting
+    quantization(params, q_flag);
+    overflow(params, o_flag);
+
+    // check for special case: -0
+    if (is_zero() && is_neg())
+        m_sign = 1;
+}
+
+
+// ----------------------------------------------------------------------------
+//  make sure, the two mantissas are aligned
+// ----------------------------------------------------------------------------
+
+void
+align(const scfx_rep &lhs, const scfx_rep &rhs, int &new_wp,
+      int &len_mant, scfx_mant_ref &lhs_mant, scfx_mant_ref &rhs_mant)
+{
+    bool need_lhs = true;
+    bool need_rhs = true;
+
+    if (lhs.m_wp != rhs.m_wp || lhs.size() != rhs.size()) {
+        int lower_bound_lhs = lhs.m_lsw - lhs.m_wp;
+        int upper_bound_lhs = lhs.m_msw - lhs.m_wp;
+        int lower_bound_rhs = rhs.m_lsw - rhs.m_wp;
+        int upper_bound_rhs = rhs.m_msw - rhs.m_wp;
+
+        int lower_bound = sc_min(lower_bound_lhs, lower_bound_rhs);
+        int upper_bound = sc_max(upper_bound_lhs, upper_bound_rhs);
+
+        new_wp = -lower_bound;
+        len_mant = sc_max(min_mant, upper_bound - lower_bound + 1);
+
+        if (new_wp != lhs.m_wp || len_mant != lhs.size()) {
+            lhs_mant = lhs.resize(len_mant, new_wp);
+            need_lhs = false;
+        }
+
+        if (new_wp != rhs.m_wp || len_mant != rhs.size()) {
+            rhs_mant = rhs.resize(len_mant, new_wp);
+            need_rhs = false;
+        }
+    }
+
+    if (need_lhs) {
+        lhs_mant = lhs.m_mant;
+    }
+
+    if (need_rhs) {
+        rhs_mant = rhs.m_mant;
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  compare two mantissas
+// ----------------------------------------------------------------------------
+
+int
+compare_msw_ff(const scfx_rep &lhs, const scfx_rep &rhs)
+{
+    // special case: rhs.m_mant[rhs.m_msw + 1] == 1
+    if (rhs.m_msw < rhs.size() - 1 && rhs.m_mant[rhs.m_msw + 1 ] != 0) {
+        return -1;
+    }
+
+    int lhs_size = lhs.m_msw - lhs.m_lsw + 1;
+    int rhs_size = rhs.m_msw - rhs.m_lsw + 1;
+
+    int size = sc_min(lhs_size, rhs_size);
+
+    int lhs_index = lhs.m_msw;
+    int rhs_index = rhs.m_msw;
+
+    int i;
+
+    for (i = 0;
+         i < size && lhs.m_mant[lhs_index] == rhs.m_mant[rhs_index];
+         i++) {
+        lhs_index--;
+        rhs_index--;
+    }
+
+    if (i == size) {
+        if (lhs_size == rhs_size) {
+            return 0;
+        }
+
+        if (lhs_size < rhs_size) {
+            return -1;
+        } else {
+            return 1;
+        }
+    }
+
+    if (lhs.m_mant[lhs_index] < rhs.m_mant[rhs_index]) {
+        return -1;
+    } else {
+        return 1;
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  divide the mantissa by ten
+// ----------------------------------------------------------------------------
+
+unsigned int
+scfx_rep::divide_by_ten()
+{
+#if defined(SC_BOOST_BIG_ENDIAN)
+    half_word *hw = (half_word *)&m_mant[m_msw];
+#elif defined(SC_BOOST_LITTLE_ENDIAN)
+    half_word *hw = ((half_word *)&m_mant[m_msw]) + 1;
+#endif
+
+    unsigned int remainder = 0;
+
+    word_short ls;
+    ls.l = 0;
+
+#if defined(SC_BOOST_BIG_ENDIAN)
+    for (int i = 0, end = (m_msw - m_wp + 1) * 2; i < end; i++) {
+#elif defined(SC_BOOST_LITTLE_ENDIAN)
+    for (int i = 0, end = -(m_msw - m_wp + 1) * 2; i > end; i--) {
+#endif
+        ls.s.u = static_cast<half_word>(remainder);
+        ls.s.l = hw[i];
+        remainder = ls.l % 10;
+        ls.l /= 10;
+        hw[i] = ls.s.l;
+    }
+
+    return remainder;
+}
+
+
+// ----------------------------------------------------------------------------
+//  multiply the mantissa by ten
+// ----------------------------------------------------------------------------
+
+void
+scfx_rep::multiply_by_ten()
+{
+    int size = m_mant.size() + 1;
+
+    scfx_mant mant8(size);
+    scfx_mant mant2(size);
+
+    size--;
+
+    mant8[size] = (m_mant[size - 1] >> (bits_in_word - 3));
+    mant2[size] = (m_mant[size - 1] >> (bits_in_word - 1));
+
+    while (--size) {
+        mant8[size] = (m_mant[size] << 3) |
+                      (m_mant[size - 1] >> (bits_in_word - 3));
+        mant2[size] = (m_mant[size] << 1) |
+                      (m_mant[size - 1] >> (bits_in_word - 1));
+    }
+
+    mant8[0] = (m_mant[0] << 3);
+    mant2[0] = (m_mant[0] << 1);
+
+    add_mants(m_mant.size(), m_mant, mant8, mant2);
+}
+
+
+// ----------------------------------------------------------------------------
+//  normalize
+// ----------------------------------------------------------------------------
+
+void
+scfx_rep::normalize(int exponent)
+{
+    int shift = exponent % bits_in_word;
+    if (shift < 0) {
+        shift += bits_in_word;
+    }
+
+    if (shift) {
+        shift_left(shift);
+    }
+
+    find_sw();
+
+    m_wp = (shift - exponent) / bits_in_word;
+}
+
+
+// ----------------------------------------------------------------------------
+//  return a new mantissa that is aligned and resized
+// ----------------------------------------------------------------------------
+
+scfx_mant *
+scfx_rep::resize(int new_size, int new_wp) const
+{
+    scfx_mant *result = new scfx_mant(new_size);
+
+    result->clear();
+
+    int shift = new_wp - m_wp;
+
+    for (int j = m_lsw; j <= m_msw; j++) {
+        (*result)[j + shift] = m_mant[j];
+    }
+
+    return result;
+}
+
+
+// ----------------------------------------------------------------------------
+//  set a single bit
+// ----------------------------------------------------------------------------
+
+void
+scfx_rep::set_bin(int i)
+{
+    m_mant[i >> 5] |= 1 << (i & 31);
+}
+
+
+// ----------------------------------------------------------------------------
+//  set three bits
+// ----------------------------------------------------------------------------
+
+void
+scfx_rep::set_oct(int i, int n)
+{
+    if (n & 1) {
+        m_mant[i >> 5] |= 1 << (i & 31);
+    }
+    i++;
+    if (n & 2) {
+        m_mant[i >> 5] |= 1 << (i & 31);
+    }
+    i++;
+    if (n & 4) {
+        m_mant[i >> 5] |= 1 << (i & 31);
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  set four bits
+// ----------------------------------------------------------------------------
+
+void
+scfx_rep::set_hex(int i, int n)
+{
+    if (n & 1) {
+        m_mant[i >> 5] |= 1 << (i & 31);
+    }
+    i++;
+    if (n & 2) {
+        m_mant[i >> 5] |= 1 << (i & 31);
+    }
+    i++;
+    if (n & 4) {
+        m_mant[i >> 5] |= 1 << (i & 31);
+    }
+    i++;
+    if (n & 8) {
+        m_mant[i >> 5] |= 1 << (i & 31);
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  PRIVATE METHOD : shift_left
+//
+//  Shifts a scfx_rep to the left by a MAXIMUM of bits_in_word - 1 bits.
+// ----------------------------------------------------------------------------
+
+void
+scfx_rep::shift_left(int n)
+{
+    if (n != 0) {
+        int shift_left = n;
+        int shift_right = bits_in_word - n;
+
+        SC_ASSERT_(!(m_mant[size() - 1] >> shift_right),
+                   "shift_left overflow");
+
+        for (int i = size() - 1; i > 0; i--) {
+            m_mant[i] = (m_mant[i] << shift_left) |
+                        (m_mant[i - 1] >> shift_right);
+        }
+        m_mant[0] <<= shift_left;
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  PRIVATE METHOD : shift_right
+//
+//  Shifts a scfx_rep to the right by a MAXIMUM of bits_in_word - 1 bits.
+// ----------------------------------------------------------------------------
+
+void
+scfx_rep::shift_right(int n)
+{
+    if (n != 0) {
+        int shift_left = bits_in_word - n;
+        int shift_right = n;
+
+        SC_ASSERT_(!(m_mant[0] << shift_left), "shift_right overflow");
+
+        for (int i = 0; i < size() - 1; i++) {
+            m_mant[i] = (m_mant[i] >> shift_right) |
+                        (m_mant[i + 1] << shift_left);
+        }
+        m_mant[size() - 1] >>= shift_right;
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  METHOD : get_bit
+//
+//  Tests a bit, in two's complement.
+// ----------------------------------------------------------------------------
+
+bool
+scfx_rep::get_bit(int i) const
+{
+    if (!is_normal())
+        return false;
+
+    scfx_index x = calc_indices(i);
+
+    if (x.wi() >= size())
+        return is_neg();
+
+    if (x.wi() < 0)
+        return false;
+
+    const_cast<scfx_rep*>(this)->toggle_tc();
+
+    bool result = (m_mant[x.wi()] & (1 << x.bi())) != 0;
+
+    const_cast<scfx_rep *>(this)->toggle_tc();
+
+    return result;
+}
+
+
+// ----------------------------------------------------------------------------
+//  METHOD : set
+//
+//  Sets a bit, in two's complement, between iwl-1 and -fwl.
+// ----------------------------------------------------------------------------
+
+bool
+scfx_rep::set(int i, const scfx_params &params)
+{
+    if (!is_normal())
+        return false;
+
+    scfx_index x = calc_indices(i);
+
+    if (x.wi() >= size()) {
+        if (is_neg())
+            return true;
+        else
+            resize_to(x.wi() + 1, 1);
+    } else if (x.wi() < 0) {
+        resize_to(size() - x.wi(), -1);
+        x.wi(0);
+    }
+
+    toggle_tc();
+
+    m_mant[x.wi()] |= 1 << x.bi();
+
+    if (i == params.iwl() - 1)
+        o_extend(x, params.enc()); // sign extension
+
+    toggle_tc();
+
+    find_sw();
+
+    return true;
+}
+
+
+// ----------------------------------------------------------------------------
+//  METHOD : clear
+//
+//  Clears a bit, in two's complement, between iwl-1 and -fwl.
+// ----------------------------------------------------------------------------
+
+bool
+scfx_rep::clear(int i, const scfx_params &params)
+{
+    if (!is_normal())
+        return false;
+
+    scfx_index x = calc_indices(i);
+
+    if (x.wi() >= size()) {
+        if (!is_neg())
+            return true;
+        else
+            resize_to(x.wi() + 1, 1);
+    } else if (x.wi() < 0) {
+        return true;
+    }
+
+    toggle_tc();
+
+    m_mant[x.wi()] &= ~(1 << x.bi());
+
+    if (i == params.iwl() - 1)
+        o_extend(x, params.enc()); // sign extension
+
+    toggle_tc();
+
+    find_sw();
+
+    return true;
+}
+
+
+// ----------------------------------------------------------------------------
+//  METHOD : get_slice
+// ----------------------------------------------------------------------------
+
+bool
+scfx_rep::get_slice(int i, int j, const scfx_params &, sc_bv_base &bv) const
+{
+    if (is_nan() || is_inf())
+        return false;
+
+    // get the bits
+
+    int l = j;
+    for (int k = 0; k < bv.length(); ++k) {
+        bv[k] = get_bit(l);
+
+        if (i >= j)
+            ++l;
+        else
+            --l;
+    }
+
+    return true;
+}
+
+bool
+scfx_rep::set_slice(int i, int j, const scfx_params &params,
+                    const sc_bv_base &bv)
+{
+    if (is_nan() || is_inf())
+        return false;
+
+    // set the bits
+    int l = j;
+    for (int k = 0; k < bv.length(); ++k) {
+        if (bv[k].to_bool())
+            set(l, params);
+        else
+            clear(l, params);
+
+        if (i >= j)
+            ++l;
+        else
+            --l;
+    }
+
+    return true;
+}
+
+
+// ----------------------------------------------------------------------------
+//  METHOD : print
+// ----------------------------------------------------------------------------
+
+void
+scfx_rep::print(::std::ostream &os) const
+{
+    os << to_string(SC_DEC, -1, SC_E);
+}
+
+
+// ----------------------------------------------------------------------------
+//  METHOD : dump
+// ----------------------------------------------------------------------------
+
+void
+scfx_rep::dump(::std::ostream &os) const
+{
+    os << "scfx_rep" << ::std::endl;
+    os << "(" << ::std::endl;
+
+    os << "mant  =" << ::std::endl;
+    for (int i = size() - 1; i >= 0; i--) {
+        char buf[BUFSIZ];
+        std::sprintf(buf, " %d: %10u (%8x)", i,
+                     (int)m_mant[i], (int)m_mant[i]);
+        os << buf << ::std::endl;
+    }
+
+    os << "wp = " << m_wp << ::std::endl;
+    os << "sign = " << m_sign << ::std::endl;
+
+    os << "state = ";
+    switch (m_state) {
+      case normal:
+        os << "normal";
+        break;
+      case infinity:
+        os << "infinity";
+        break;
+      case not_a_number:
+        os << "not_a_number";
+        break;
+      default:
+        os << "unknown";
+    }
+    os << ::std::endl;
+
+    os << "msw = " << m_msw << ::std::endl;
+    os << "lsw = " << m_lsw << ::std::endl;
+
+    os << ")" << ::std::endl;
+}
+
+
+// ----------------------------------------------------------------------------
+//  METHOD : get_type
+// ----------------------------------------------------------------------------
+
+void
+scfx_rep::get_type(int &wl, int &iwl, sc_enc &enc) const
+{
+    if (is_nan() || is_inf()) {
+        wl  = 0;
+        iwl = 0;
+        enc = SC_TC_;
+        return;
+    }
+
+    if (is_zero()) {
+        wl  = 1;
+        iwl = 1;
+        enc = SC_US_;
+        return;
+    }
+
+    int msb = (m_msw - m_wp) * bits_in_word +
+              scfx_find_msb(m_mant[ m_msw ]) + 1;
+    while (get_bit(msb) == get_bit(msb - 1)) {
+        --msb;
+    }
+
+    int lsb = (m_lsw - m_wp) * bits_in_word +
+              scfx_find_lsb(m_mant[m_lsw]);
+
+    if (is_neg()) {
+        wl  = msb - lsb + 1;
+        iwl = msb + 1;
+        enc = SC_TC_;
+    } else {
+        wl  = msb - lsb;
+        iwl = msb;
+        enc = SC_US_;
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  PRIVATE METHOD : round
+//
+//  Performs convergent rounding (rounding to even) as in floating-point.
+// ----------------------------------------------------------------------------
+
+void
+scfx_rep::round(int wl)
+{
+    // check for special cases
+
+    if (is_nan() || is_inf() || is_zero())
+        return;
+
+    // estimate effective wordlength and compare
+    int wl_effective;
+    wl_effective = (m_msw - m_lsw + 1) * bits_in_word;
+    if (wl_effective <= wl)
+        return;
+
+    // calculate effective wordlength and compare
+    int msb = scfx_find_msb(m_mant[m_msw]);
+    int lsb = scfx_find_lsb(m_mant[m_lsw]);
+    wl_effective = (m_msw * bits_in_word + msb) -
+                   (m_lsw * bits_in_word + lsb) + 1;
+    if (wl_effective <= wl)
+        return;
+
+    // perform rounding
+    int wi = m_msw - (wl - 1) / bits_in_word;
+    int bi = msb - (wl - 1) % bits_in_word;
+    if (bi < 0) {
+        --wi;
+        bi += bits_in_word;
+    }
+
+    scfx_index x(wi, bi);
+
+    if ((q_bit(x) && ! q_zero(x)) || (q_bit(x) && q_zero(x) && q_odd(x))) {
+        q_incr(x);
+    }
+    q_clear(x);
+
+    find_sw();
+
+    m_r_flag = true;
+}
+
+} // namespace sc_dt
diff --git a/src/systemc/dt/fx/scfx_utils.cc b/src/systemc/dt/fx/scfx_utils.cc
new file mode 100644
index 0000000..844e15d
--- /dev/null
+++ b/src/systemc/dt/fx/scfx_utils.cc
@@ -0,0 +1,162 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  scfx_utils.cpp -
+
+  Original Author: Martin Janssen, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: scfx_utils.cpp,v $
+// Revision 1.1.1.1  2006/12/15 20:20:04  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:53:58  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#include "systemc/ext/dt/fx/scfx_utils.hh"
+
+namespace sc_dt
+{
+
+void
+scfx_tc2csd(scfx_string &s, int w_prefix)
+{
+    if (w_prefix != 0) {
+        SC_ASSERT_(s[0] == '0' && s[1] == 'c' &&
+                   s[2] == 's' && s[3] == 'd', "invalid prefix");
+    }
+
+    scfx_string csd;
+
+    // copy bits from 's' into 'csd'; skip prefix, point, and exponent
+    int i = 0;
+    int j = (w_prefix != 0 ? 4 : 0);
+    while (s[j]) {
+        if (s[j] == '0' || s[j] == '1')
+            csd[i ++] = s[j];
+        else if (s[j] != '.')
+            break;
+        ++j;
+    }
+    csd[i] = '\0';
+
+    // convert 'csd' from two's complement to csd
+    --i;
+    while (i >= 0) {
+        if (csd[i] == '0') {
+            --i;
+        } else {
+            if (i > 0 && csd[i - 1] == '0') {
+                --i;
+            } else if (i == 0) {
+                csd[i--] = '-';
+            } else {
+                csd[i--] = '-';
+                while (i >= 0 && csd[i] == '1')
+                    csd[i--] = '0';
+                if (i > 0)
+                    csd[i] = '1';
+                else if (i == 0)
+                    csd[i--] = '1';
+            }
+        }
+    }
+
+    // copy bits from 'csd' back into 's'
+    i = 0;
+    j = (w_prefix != 0 ? 4 : 0);
+    while (csd[i]) {
+        if (s[j] == '.')
+            ++j;
+        s[j++] = csd[i++];
+    }
+}
+
+
+void
+scfx_csd2tc(scfx_string &csd)
+{
+    SC_ASSERT_(csd[0] == '0' && csd[1] == 'c' &&
+               csd[2] == 's' && csd[3] == 'd', "invalid prefix");
+
+    scfx_string s;
+
+    // copy bits from 'csd' into 's'; skip prefix, point, and exponent
+    int i = 0;
+    s[i++] = '0';
+    int j = 4;
+    while (csd[j]) {
+        if (csd[j] == '-' || csd[j] == '0' || csd[j] == '1')
+            s[i++] = csd[j];
+        else if (csd[j] != '.')
+            break;
+        ++j;
+    }
+    s[i] = '\0';
+
+    // convert 's' from csd to two's complement
+    int len = i;
+    i = 1;
+    while (i < len) {
+        while (i < len && s[i] != '-')
+            i++;
+        if (i < len) {
+            j = i++;
+            s[j--] = '1';
+            while (j >= 0 && s[j] == '0')
+                s[j--] = '1';
+            if (j >= 0)
+                s[j] = '0';
+        }
+    }
+
+    // copy bits from 's' back into 'csd'
+    j = csd.length();
+    csd[j + 1] = '\0';
+    while (j > 4) {
+        csd[j] = csd[j - 1];
+        --j;
+    }
+
+    i = 0;
+    j = 4;
+    while (s[i]) {
+        if (csd[j] == '.')
+            ++j;
+        csd[j++] = s[i++];
+    }
+}
+
+} // namespace sc_dt
diff --git a/src/systemc/dt/int/SConscript b/src/systemc/dt/int/SConscript
new file mode 100644
index 0000000..93e01b2
--- /dev/null
+++ b/src/systemc/dt/int/SConscript
@@ -0,0 +1,38 @@
+# Copyright 2018 Google, Inc.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met: redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer;
+# redistributions in binary form must reproduce the above copyright
+# notice, this list of conditions and the following disclaimer in the
+# documentation and/or other materials provided with the distribution;
+# neither the name of the copyright holders nor the names of its
+# 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
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+# Authors: Gabe Black
+
+Import('*')
+
+if env['USE_SYSTEMC']:
+    Source('sc_int_base.cc')
+    Source('sc_int_mask.cc')
+    Source('sc_length_param.cc')
+    Source('sc_nbexterns.cc')
+    Source('sc_nbutils.cc')
+    Source('sc_signed.cc')
+    Source('sc_uint_base.cc')
+    Source('sc_unsigned.cc')
diff --git a/src/systemc/dt/int/sc_int_base.cc b/src/systemc/dt/int/sc_int_base.cc
new file mode 100644
index 0000000..d5b005b
--- /dev/null
+++ b/src/systemc/dt/int/sc_int_base.cc
@@ -0,0 +1,706 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_int_base.cpp -- contains interface definitions between sc_int and
+                sc_signed, sc_unsigned, and definitions for sc_int_subref.
+
+  Original Author: Ali Dasdan, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: sc_int_base.cpp,v $
+// Revision 1.5  2011/02/18 20:19:14  acg
+//  Andy Goodrich: updating Copyright notice.
+//
+// Revision 1.4  2010/02/04 22:23:29  acg
+//  Andy Goodrich: fixed bug in concatenation reads for part selections,
+//  the mask being used was 32 bits and should have been 64 bits.
+//
+// Revision 1.3  2008/06/19 17:47:56  acg
+//  Andy Goodrich: fixes for bugs. See 2.2.1 RELEASENOTES.
+//
+// Revision 1.2  2007/11/04 21:27:00  acg
+//  Andy Goodrich: changes to make sure the proper value is returned from
+//  concat_get_data().
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:49:31  acg
+// Added $Log command so that CVS check in comments are reproduced in the
+// source.
+//
+
+#include <sstream>
+
+#include "systemc/ext/dt/bit/sc_bv_base.hh"
+#include "systemc/ext/dt/bit/sc_lv_base.hh"
+#include "systemc/ext/dt/fx/sc_fix.hh"
+#include "systemc/ext/dt/fx/scfx_other_defs.hh"
+#include "systemc/ext/dt/int/sc_int_base.hh"
+#include "systemc/ext/dt/int/sc_signed.hh"
+#include "systemc/ext/dt/int/sc_uint_base.hh"
+#include "systemc/ext/dt/int/sc_unsigned.hh"
+#include "systemc/ext/dt/misc/sc_concatref.hh"
+
+// explicit template instantiations
+namespace sc_core
+{
+
+template class sc_vpool<sc_dt::sc_int_bitref>;
+template class sc_vpool<sc_dt::sc_int_subref>;
+
+} // namespace sc_core
+
+namespace sc_dt
+{
+
+// to avoid code bloat in sc_int_concref<T1,T2>
+
+void
+sc_int_concref_invalid_length(int length)
+{
+    std::stringstream msg;
+    msg << "sc_int_concref<T1,T2> initialization: length = " << length <<
+           "violates 1 <= length <= " << SC_INTWIDTH;
+    SC_REPORT_ERROR("out of bounds", msg.str().c_str());
+    sc_core::sc_abort(); // can't recover from here
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_int_bitref
+//
+//  Proxy class for sc_int bit selection (r-value and l-value).
+// ----------------------------------------------------------------------------
+
+sc_core::sc_vpool<sc_int_bitref> sc_int_bitref::m_pool(9);
+
+// concatenation methods:
+
+// #### OPTIMIZE
+void sc_int_bitref::concat_set(int64 src, int low_i)
+{
+    sc_int_base aa(1);
+    *this = aa = (low_i < 64) ? src >> low_i : src >> 63;
+}
+
+void sc_int_bitref::concat_set(const sc_signed &src, int low_i)
+{
+    sc_int_base aa(1);
+    if (low_i < src.length())
+        *this = aa = 1 & (src >> low_i);
+    else
+        *this = aa = (src < 0) ? (int_type)-1 : 0;
+}
+
+void sc_int_bitref::concat_set(const sc_unsigned &src, int low_i)
+{
+    sc_int_base aa(1);
+    if (low_i < src.length())
+        *this = aa = 1 & (src >> low_i);
+    else
+        *this = aa = 0;
+}
+
+void sc_int_bitref::concat_set(uint64 src, int low_i)
+{
+    sc_int_base aa(1);
+    *this = aa = (low_i < 64) ? src >> low_i : 0;
+}
+
+
+// other methods
+void
+sc_int_bitref::scan(::std::istream &is)
+{
+    bool b;
+    is >> b;
+    *this = b;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_int_subref_r
+//
+//  Proxy class for sc_int part selection (l-value).
+// ----------------------------------------------------------------------------
+
+bool
+sc_int_subref_r::concat_get_ctrl(sc_digit *dst_p, int low_i) const
+{
+    int dst_i; // Word in dst_p now processing.
+    int end_i; // Highest order word in dst_p to process.
+    int high_i; // Index of high order bit in dst_p to set.
+    uint_type mask; // Mask for bits to extract or keep.
+
+    dst_i = low_i / BITS_PER_DIGIT;
+    high_i = low_i + (m_left - m_right);
+    end_i = high_i / BITS_PER_DIGIT;
+    mask = ~mask_int[m_left][m_right];
+
+    // PROCESS THE FIRST WORD:
+    dst_p[dst_i] = (sc_digit)(dst_p[dst_i] & mask);
+    switch (end_i - dst_i) {
+      // BITS ARE ACROSS TWO WORDS:
+      case 1:
+        dst_i++;
+        dst_p[dst_i] = 0;
+        break;
+
+      // BITS ARE ACROSS THREE WORDS:
+      case 2:
+        dst_i++;
+        dst_p[dst_i++] = 0;
+        dst_p[dst_i] = 0;
+        break;
+
+      // BITS ARE ACROSS FOUR WORDS:
+      case 3:
+        dst_i++;
+        dst_p[dst_i++] = 0;
+        dst_p[dst_i++] = 0;
+        dst_p[dst_i] = 0;
+        break;
+    }
+    return false;
+}
+
+bool
+sc_int_subref_r::concat_get_data(sc_digit *dst_p, int low_i) const
+{
+    int dst_i; // Word in dst_p now processing.
+    int end_i; // Highest order word in dst_p to process.
+    int high_i; // Index of high order bit in dst_p to set.
+    int left_shift; // Left shift for val.
+    uint_type mask; // Mask for bits to extract or keep.
+    bool non_zero; // True if value inserted is non-zero.
+    uint_type val; // Selection value extracted from m_obj_p.
+
+    dst_i = low_i / BITS_PER_DIGIT;
+    left_shift = low_i % BITS_PER_DIGIT;
+    high_i = low_i + (m_left-m_right);
+    end_i = high_i / BITS_PER_DIGIT;
+    mask = ~mask_int[m_left][m_right];
+    val = (m_obj_p->m_val & mask) >> m_right;
+    non_zero = val != 0;
+
+    // PROCESS THE FIRST WORD:
+    mask = ~(~UINT_ZERO << left_shift);
+    dst_p[dst_i] = (sc_digit)((dst_p[dst_i] & mask) |
+                ((val << left_shift) & DIGIT_MASK));
+
+    switch (end_i - dst_i) {
+      // BITS ARE ACROSS TWO WORDS:
+      case 1:
+        dst_i++;
+        val >>= (BITS_PER_DIGIT - left_shift);
+        dst_p[dst_i] = (sc_digit)(val & DIGIT_MASK);
+        break;
+
+      // BITS ARE ACROSS THREE WORDS:
+      case 2:
+        dst_i++;
+        val >>= (BITS_PER_DIGIT - left_shift);
+        dst_p[dst_i++] = (sc_digit)(val & DIGIT_MASK);
+        val >>= BITS_PER_DIGIT;
+        dst_p[dst_i] = (sc_digit)val;
+        break;
+
+      // BITS ARE ACROSS FOUR WORDS:
+      case 3:
+        dst_i++;
+        val >>= (BITS_PER_DIGIT - left_shift);
+        dst_p[dst_i++] = (sc_digit)(val & DIGIT_MASK);
+        val >>= BITS_PER_DIGIT;
+        dst_p[dst_i++] = (sc_digit)(val & DIGIT_MASK);
+        val >>= BITS_PER_DIGIT;
+        dst_p[dst_i] = (sc_digit)val;
+        break;
+    }
+    return non_zero;
+}
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_int_subref
+//
+//  Proxy class for sc_int part selection (r-value and l-value).
+// ----------------------------------------------------------------------------
+
+sc_core::sc_vpool<sc_int_subref> sc_int_subref::m_pool(9);
+
+// assignment operators
+
+sc_int_subref &
+sc_int_subref::operator = (int_type v)
+{
+    int_type val = m_obj_p->m_val;
+    uint_type mask = mask_int[m_left][m_right];
+    val &= mask;
+    val |= (v << m_right) & ~mask;
+    m_obj_p->m_val = val;
+    m_obj_p->extend_sign();
+    return *this;
+}
+
+sc_int_subref &
+sc_int_subref::operator = (const sc_signed &a)
+{
+    sc_int_base aa(length());
+    return (*this = aa = a);
+}
+
+sc_int_subref &
+sc_int_subref::operator = (const sc_unsigned &a)
+{
+    sc_int_base aa(length());
+    return (*this = aa = a);
+}
+
+sc_int_subref &
+sc_int_subref::operator = (const sc_bv_base &a)
+{
+    sc_int_base aa(length());
+    return (*this = aa = a);
+}
+
+sc_int_subref &
+sc_int_subref::operator = (const sc_lv_base &a)
+{
+    sc_int_base aa(length());
+    return (*this = aa = a);
+}
+
+
+// concatenation methods:
+// #### OPTIMIZE
+void
+sc_int_subref::concat_set(int64 src, int low_i)
+{
+    sc_int_base aa(length());
+    *this = aa = (low_i < 64) ? src >> low_i : src >> 63;
+}
+
+void
+sc_int_subref::concat_set(const sc_signed &src, int low_i)
+{
+    sc_int_base aa(length());
+    if (low_i < src.length())
+        *this = aa = src >> low_i;
+    else
+        *this = (src < 0) ? (int_type)-1 : 0;
+}
+
+void
+sc_int_subref::concat_set(const sc_unsigned &src, int low_i)
+{
+    sc_int_base aa(length());
+    if (low_i < src.length())
+        *this = aa = src >> low_i;
+    else
+        *this = 0;
+}
+
+void
+sc_int_subref::concat_set(uint64 src, int low_i)
+{
+    sc_int_base aa (length());
+    *this = aa = (low_i < 64) ? src >> low_i : 0;
+}
+
+
+// other methods
+void
+sc_int_subref::scan(::std::istream &is)
+{
+    std::string s;
+    is >> s;
+    *this = s.c_str();
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_int_base
+//
+//  Base class for sc_int.
+// ----------------------------------------------------------------------------
+
+// support methods
+void
+sc_int_base::invalid_length() const
+{
+    std::stringstream msg;
+    msg << "sc_int[_base] initialization: length = " << m_len <<
+           " violates 1 <= length <= " << SC_INTWIDTH;
+    SC_REPORT_ERROR("out of bounds", msg.str().c_str());
+    sc_core::sc_abort(); // can't recover from here
+}
+
+void
+sc_int_base::invalid_index(int i) const
+{
+    std::stringstream msg;
+    msg << "sc_int[_base] bit selection: index = " << i <<
+           " violates 0 <= index <= " << (m_len - 1);
+    SC_REPORT_ERROR("out of bounds", msg.str().c_str());
+    sc_core::sc_abort(); // can't recover from here
+}
+
+void
+sc_int_base::invalid_range(int l, int r) const
+{
+    std::stringstream msg;
+    msg << "sc_int[_base] part selection: " <<
+           "left = " << l << ", right = " << r << " violates " <<
+           (m_len-1) << " >= left >= right >= 0";
+    SC_REPORT_ERROR("out of bounds", msg.str().c_str());
+    sc_core::sc_abort(); // can't recover from here
+}
+
+void
+sc_int_base::check_value() const
+{
+    int_type limit = (int_type)1 << (m_len - 1);
+    if (m_val < -limit || m_val >= limit) {
+        std::stringstream msg;
+        msg << "sc_int[_base]: value does not fit into a length of " << m_len;
+        SC_REPORT_WARNING("out of bounds", msg.str().c_str());
+    }
+}
+
+
+// constructors
+sc_int_base::sc_int_base(const sc_bv_base &v) :
+    m_val(0), m_len(v.length()), m_ulen(SC_INTWIDTH - m_len)
+{
+    check_length();
+    *this = v;
+}
+sc_int_base::sc_int_base(const sc_lv_base &v) :
+    m_val(0), m_len(v.length()), m_ulen(SC_INTWIDTH - m_len)
+{
+    check_length();
+    *this = v;
+}
+sc_int_base::sc_int_base(const sc_uint_subref_r &v) :
+    m_val(0), m_len(v.length()), m_ulen(SC_INTWIDTH - m_len)
+{
+    check_length();
+    *this = v.to_uint64();
+}
+sc_int_base::sc_int_base(const sc_signed_subref_r &v) :
+    m_val(0), m_len(v.length()), m_ulen(SC_INTWIDTH - m_len)
+{
+    check_length();
+    *this = v.to_uint64();
+}
+sc_int_base::sc_int_base(const sc_unsigned_subref_r &v) :
+    m_val(0), m_len(v.length()), m_ulen(SC_INTWIDTH - m_len)
+{
+    check_length();
+    *this = v.to_uint64();
+}
+
+sc_int_base::sc_int_base(const sc_signed &a) :
+    m_val(0), m_len(a.length()), m_ulen(SC_INTWIDTH - m_len)
+{
+    check_length();
+    *this = a.to_int64();
+}
+
+sc_int_base::sc_int_base(const sc_unsigned &a) :
+    m_val(0), m_len(a.length()), m_ulen(SC_INTWIDTH - m_len)
+{
+    check_length();
+    *this = a.to_int64();
+}
+
+
+// assignment operators
+sc_int_base &
+sc_int_base::operator = (const sc_signed &a)
+{
+    int minlen = sc_min(m_len, a.length());
+    int i = 0;
+    for (; i < minlen; ++i) {
+        set(i, a.test(i));
+    }
+    bool sgn = a.sign();
+    for (; i < m_len; ++i) {
+        // sign extension
+        set(i, sgn);
+    }
+    extend_sign();
+    return *this;
+}
+
+sc_int_base &
+sc_int_base::operator = (const sc_unsigned &a)
+{
+    int minlen = sc_min(m_len, a.length());
+    int i = 0;
+    for (; i < minlen; ++i) {
+        set(i, a.test(i));
+    }
+    for (; i < m_len; ++i) {
+        // zero extension
+        set(i, 0);
+    }
+    extend_sign();
+    return *this;
+}
+
+
+sc_int_base &
+sc_int_base::operator = (const sc_bv_base &a)
+{
+    int minlen = sc_min(m_len, a.length());
+    int i = 0;
+    for (; i < minlen; ++i) {
+        set(i, a.get_bit(i));
+    }
+    for (; i < m_len; ++i) {
+        // zero extension
+        set(i, 0);
+    }
+    extend_sign();
+    return *this;
+}
+
+sc_int_base &
+sc_int_base::operator = (const sc_lv_base &a)
+{
+    int minlen = sc_min(m_len, a.length());
+    int i = 0;
+    for (; i < minlen; ++i) {
+        set(i, sc_logic(a.get_bit(i)).to_bool());
+    }
+    for (; i < m_len; ++i) {
+        // zero extension
+        set(i, 0);
+    }
+    extend_sign();
+    return *this;
+}
+
+sc_int_base &
+sc_int_base::operator = (const char *a)
+{
+    if (a == 0) {
+        SC_REPORT_ERROR("conversion failed",
+                        "character string is zero");
+    } else if (*a == 0) {
+        SC_REPORT_ERROR("conversion failed",
+                        "character string is empty");
+    } else try {
+        int len = m_len;
+        sc_fix aa(a, len, len, SC_TRN, SC_WRAP, 0, SC_ON);
+        return this->operator = (aa);
+    } catch(const sc_core::sc_report &) {
+        std::stringstream msg;
+        msg << "character string '" << a << "' is not valid";
+        SC_REPORT_ERROR("conversion failed", msg.str().c_str());
+    }
+    return *this;
+}
+
+// explicit conversion to character string
+const std::string
+sc_int_base::to_string(sc_numrep numrep) const
+{
+    int len = m_len;
+    sc_fix aa(*this, len, len, SC_TRN, SC_WRAP, 0, SC_ON);
+    return aa.to_string(numrep);
+}
+
+const std::string
+sc_int_base::to_string(sc_numrep numrep, bool w_prefix) const
+{
+    int len = m_len;
+    sc_fix aa(*this, len, len, SC_TRN, SC_WRAP, 0, SC_ON);
+    return aa.to_string(numrep, w_prefix);
+}
+
+
+// reduce methods
+bool sc_int_base::and_reduce() const { return (m_val == int_type(-1)); }
+bool sc_int_base::or_reduce() const { return (m_val != int_type(0)); }
+
+bool
+sc_int_base::xor_reduce() const
+{
+    uint_type mask = ~UINT_ZERO;
+    uint_type val = m_val & (mask >> m_ulen);
+    int n = SC_INTWIDTH;
+    do {
+        n >>= 1;
+        mask >>= n;
+        val = ((val & (mask << n)) >> n) ^ (val & mask);
+    } while (n != 1);
+    return (val != uint_type(0));
+}
+
+bool
+sc_int_base::concat_get_ctrl(sc_digit *dst_p, int low_i) const
+{
+    int dst_i; // Word in dst_p now processing.
+    int end_i; // Highest order word in dst_p to process.
+    int left_shift; // Left shift for val.
+    uint_type mask; // Mask for bits to extract or keep.
+
+    dst_i = low_i / BITS_PER_DIGIT;
+    left_shift = low_i % BITS_PER_DIGIT;
+    end_i = (low_i + (m_len - 1)) / BITS_PER_DIGIT;
+
+    mask = ~(~UINT_ZERO << left_shift);
+    dst_p[dst_i] = (sc_digit)(dst_p[dst_i] & mask);
+        dst_i++;
+        for (; dst_i <= end_i; dst_i++)
+            dst_p[dst_i] = 0;
+        return false;
+}
+
+//-----------------------------------------------------------------------------
+//"sc_int_base::concat_get_data"
+//
+// This method transfers the value of this object instance to the supplied
+// array of sc_unsigned digits starting with the bit specified by low_i within
+// the array of digits.
+//
+// Notes:
+//   (1) we don't worry about masking the high order data we transfer since
+//       concat_get_data() is called from low order bit to high order bit. So
+//       the bits above where we place ours will be filled in by someone else.
+//
+//   dst_p -> array of sc_unsigned digits to be filled in.
+//   low_i =  first bit within dst_p to be set.
+//-----------------------------------------------------------------------------
+bool
+sc_int_base::concat_get_data(sc_digit *dst_p, int low_i) const
+{
+    int dst_i; // Word in dst_p now processing.
+    int end_i; // Highest order word in dst_p to process.
+    int high_i; // Index of high order bit in dst_p to set.
+    int left_shift; // Left shift for val.
+    uint_type mask; // Mask for bits to extract or keep.
+    bool non_zero; // True if value inserted is non-zero.
+    uint_type val; // Value for this object.
+
+    dst_i = low_i / BITS_PER_DIGIT;
+    left_shift = low_i % BITS_PER_DIGIT;
+    high_i = low_i + (m_len - 1);
+    end_i = high_i / BITS_PER_DIGIT;
+    val = m_val;
+    non_zero = val != 0;
+
+    // MASK OFF DATA TO BE TRANSFERRED BASED ON WIDTH:
+    if (m_len < 64) {
+        mask = ~(~UINT_ZERO << m_len);
+        val &=  mask;
+    }
+
+    // PROCESS THE FIRST WORD:
+    mask = (~UINT_ZERO << left_shift);
+    dst_p[dst_i] = (sc_digit)((dst_p[dst_i] & ~mask) |
+            ((val <<left_shift) & DIGIT_MASK));
+    switch (end_i - dst_i) {
+      // BITS ARE ACROSS TWO WORDS:
+      case 1:
+        dst_i++;
+        val >>= (BITS_PER_DIGIT - left_shift);
+        dst_p[dst_i] = (sc_digit)val;
+        break;
+
+      // BITS ARE ACROSS THREE WORDS:
+      case 2:
+        dst_i++;
+        val >>= (BITS_PER_DIGIT - left_shift);
+        dst_p[dst_i++] = ((sc_digit)val) & DIGIT_MASK;
+        val >>= BITS_PER_DIGIT;
+        dst_p[dst_i] = (sc_digit)val;
+        break;
+
+      // BITS ARE ACROSS FOUR WORDS:
+      case 3:
+        dst_i++;
+        val >>= (BITS_PER_DIGIT - left_shift);
+        dst_p[dst_i++] = (sc_digit)(val & DIGIT_MASK);
+        val >>= BITS_PER_DIGIT;
+        dst_p[dst_i++] = (sc_digit)(val & DIGIT_MASK);
+        val >>= BITS_PER_DIGIT;
+        dst_p[dst_i] = (sc_digit)val;
+        break;
+    }
+    return non_zero;
+}
+
+// #### OPTIMIZE
+void
+sc_int_base::concat_set(int64 src, int low_i)
+{
+    *this = (low_i < 64) ? src >> low_i : src >> 63;
+}
+
+void
+sc_int_base::concat_set(const sc_signed &src, int low_i)
+{
+    if (low_i < src.length())
+        *this = src >> low_i;
+    else
+        *this = (src < 0) ? (int_type)-1 : 0;
+}
+
+void
+sc_int_base::concat_set(const sc_unsigned &src, int low_i)
+{
+    if (low_i < src.length())
+        *this = src >> low_i;
+    else
+        *this = 0;
+}
+
+void
+sc_int_base::concat_set(uint64 src, int low_i)
+{
+    *this = (low_i < 64) ? src >> low_i : 0;
+}
+
+// other methods
+void
+sc_int_base::scan(::std::istream &is)
+{
+    std::string s;
+    is >> s;
+    *this = s.c_str();
+}
+
+} // namespace sc_dt;
diff --git a/src/systemc/dt/int/sc_int_mask.cc b/src/systemc/dt/int/sc_int_mask.cc
new file mode 100644
index 0000000..85473bb
--- /dev/null
+++ b/src/systemc/dt/int/sc_int_mask.cc
@@ -0,0 +1,2268 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_int_mask.cpp -- Fills the mask_int lookup table to enable efficient
+                     part-selection on sc_ints and sc_uints.
+
+  Original Author: Amit Rao, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date: Ali Dasdan, Synopsys, Inc.
+  Description of Modification: - Resolved ambiguity with sc_(un)signed.
+                               - Merged the code for 64- and 32-bit versions
+                                 via the constants in sc_nbdefs.h.
+                               - Eliminated redundant file inclusions.
+
+      Name, Affiliation, Date: Philipp A Hartmann, Intel
+  Description of Modification: - drop specializations for Windows, 32-bit only
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+#include "systemc/ext/dt/int/sc_int_base.hh"
+#include "systemc/ext/dt/int/sc_uint_base.hh"
+
+#ifndef UINT64_C
+# define UINT64_C(v) v ## ULL
+#endif // UINT64_C
+
+namespace sc_dt {
+
+const uint_type mask_int[SC_INTWIDTH][SC_INTWIDTH] = {
+    {
+        UINT64_C(0xfffffffffffffffe)
+    },
+    {
+        UINT64_C(0xfffffffffffffffc),
+        UINT64_C(0xfffffffffffffffd)
+    },
+    {
+        UINT64_C(0xfffffffffffffff8),
+        UINT64_C(0xfffffffffffffff9),
+        UINT64_C(0xfffffffffffffffb)
+    },
+    {
+        UINT64_C(0xfffffffffffffff0),
+        UINT64_C(0xfffffffffffffff1),
+        UINT64_C(0xfffffffffffffff3),
+        UINT64_C(0xfffffffffffffff7)
+    },
+    {
+        UINT64_C(0xffffffffffffffe0),
+        UINT64_C(0xffffffffffffffe1),
+        UINT64_C(0xffffffffffffffe3),
+        UINT64_C(0xffffffffffffffe7),
+        UINT64_C(0xffffffffffffffef)
+    },
+    {
+        UINT64_C(0xffffffffffffffc0),
+        UINT64_C(0xffffffffffffffc1),
+        UINT64_C(0xffffffffffffffc3),
+        UINT64_C(0xffffffffffffffc7),
+        UINT64_C(0xffffffffffffffcf),
+        UINT64_C(0xffffffffffffffdf)
+    },
+    {
+        UINT64_C(0xffffffffffffff80),
+        UINT64_C(0xffffffffffffff81),
+        UINT64_C(0xffffffffffffff83),
+        UINT64_C(0xffffffffffffff87),
+        UINT64_C(0xffffffffffffff8f),
+        UINT64_C(0xffffffffffffff9f),
+        UINT64_C(0xffffffffffffffbf)
+    },
+    {
+        UINT64_C(0xffffffffffffff00),
+        UINT64_C(0xffffffffffffff01),
+        UINT64_C(0xffffffffffffff03),
+        UINT64_C(0xffffffffffffff07),
+        UINT64_C(0xffffffffffffff0f),
+        UINT64_C(0xffffffffffffff1f),
+        UINT64_C(0xffffffffffffff3f),
+        UINT64_C(0xffffffffffffff7f)
+    },
+    {
+        UINT64_C(0xfffffffffffffe00),
+        UINT64_C(0xfffffffffffffe01),
+        UINT64_C(0xfffffffffffffe03),
+        UINT64_C(0xfffffffffffffe07),
+        UINT64_C(0xfffffffffffffe0f),
+        UINT64_C(0xfffffffffffffe1f),
+        UINT64_C(0xfffffffffffffe3f),
+        UINT64_C(0xfffffffffffffe7f),
+        UINT64_C(0xfffffffffffffeff)
+    },
+    {
+        UINT64_C(0xfffffffffffffc00),
+        UINT64_C(0xfffffffffffffc01),
+        UINT64_C(0xfffffffffffffc03),
+        UINT64_C(0xfffffffffffffc07),
+        UINT64_C(0xfffffffffffffc0f),
+        UINT64_C(0xfffffffffffffc1f),
+        UINT64_C(0xfffffffffffffc3f),
+        UINT64_C(0xfffffffffffffc7f),
+        UINT64_C(0xfffffffffffffcff),
+        UINT64_C(0xfffffffffffffdff)
+    },
+    {
+        UINT64_C(0xfffffffffffff800),
+        UINT64_C(0xfffffffffffff801),
+        UINT64_C(0xfffffffffffff803),
+        UINT64_C(0xfffffffffffff807),
+        UINT64_C(0xfffffffffffff80f),
+        UINT64_C(0xfffffffffffff81f),
+        UINT64_C(0xfffffffffffff83f),
+        UINT64_C(0xfffffffffffff87f),
+        UINT64_C(0xfffffffffffff8ff),
+        UINT64_C(0xfffffffffffff9ff),
+        UINT64_C(0xfffffffffffffbff)
+    },
+    {
+        UINT64_C(0xfffffffffffff000),
+        UINT64_C(0xfffffffffffff001),
+        UINT64_C(0xfffffffffffff003),
+        UINT64_C(0xfffffffffffff007),
+        UINT64_C(0xfffffffffffff00f),
+        UINT64_C(0xfffffffffffff01f),
+        UINT64_C(0xfffffffffffff03f),
+        UINT64_C(0xfffffffffffff07f),
+        UINT64_C(0xfffffffffffff0ff),
+        UINT64_C(0xfffffffffffff1ff),
+        UINT64_C(0xfffffffffffff3ff),
+        UINT64_C(0xfffffffffffff7ff)
+    },
+    {
+        UINT64_C(0xffffffffffffe000),
+        UINT64_C(0xffffffffffffe001),
+        UINT64_C(0xffffffffffffe003),
+        UINT64_C(0xffffffffffffe007),
+        UINT64_C(0xffffffffffffe00f),
+        UINT64_C(0xffffffffffffe01f),
+        UINT64_C(0xffffffffffffe03f),
+        UINT64_C(0xffffffffffffe07f),
+        UINT64_C(0xffffffffffffe0ff),
+        UINT64_C(0xffffffffffffe1ff),
+        UINT64_C(0xffffffffffffe3ff),
+        UINT64_C(0xffffffffffffe7ff),
+        UINT64_C(0xffffffffffffefff)
+    },
+    {
+        UINT64_C(0xffffffffffffc000),
+        UINT64_C(0xffffffffffffc001),
+        UINT64_C(0xffffffffffffc003),
+        UINT64_C(0xffffffffffffc007),
+        UINT64_C(0xffffffffffffc00f),
+        UINT64_C(0xffffffffffffc01f),
+        UINT64_C(0xffffffffffffc03f),
+        UINT64_C(0xffffffffffffc07f),
+        UINT64_C(0xffffffffffffc0ff),
+        UINT64_C(0xffffffffffffc1ff),
+        UINT64_C(0xffffffffffffc3ff),
+        UINT64_C(0xffffffffffffc7ff),
+        UINT64_C(0xffffffffffffcfff),
+        UINT64_C(0xffffffffffffdfff)
+    },
+    {
+        UINT64_C(0xffffffffffff8000),
+        UINT64_C(0xffffffffffff8001),
+        UINT64_C(0xffffffffffff8003),
+        UINT64_C(0xffffffffffff8007),
+        UINT64_C(0xffffffffffff800f),
+        UINT64_C(0xffffffffffff801f),
+        UINT64_C(0xffffffffffff803f),
+        UINT64_C(0xffffffffffff807f),
+        UINT64_C(0xffffffffffff80ff),
+        UINT64_C(0xffffffffffff81ff),
+        UINT64_C(0xffffffffffff83ff),
+        UINT64_C(0xffffffffffff87ff),
+        UINT64_C(0xffffffffffff8fff),
+        UINT64_C(0xffffffffffff9fff),
+        UINT64_C(0xffffffffffffbfff)
+    },
+    {
+        UINT64_C(0xffffffffffff0000),
+        UINT64_C(0xffffffffffff0001),
+        UINT64_C(0xffffffffffff0003),
+        UINT64_C(0xffffffffffff0007),
+        UINT64_C(0xffffffffffff000f),
+        UINT64_C(0xffffffffffff001f),
+        UINT64_C(0xffffffffffff003f),
+        UINT64_C(0xffffffffffff007f),
+        UINT64_C(0xffffffffffff00ff),
+        UINT64_C(0xffffffffffff01ff),
+        UINT64_C(0xffffffffffff03ff),
+        UINT64_C(0xffffffffffff07ff),
+        UINT64_C(0xffffffffffff0fff),
+        UINT64_C(0xffffffffffff1fff),
+        UINT64_C(0xffffffffffff3fff),
+        UINT64_C(0xffffffffffff7fff)
+    },
+    {
+        UINT64_C(0xfffffffffffe0000),
+        UINT64_C(0xfffffffffffe0001),
+        UINT64_C(0xfffffffffffe0003),
+        UINT64_C(0xfffffffffffe0007),
+        UINT64_C(0xfffffffffffe000f),
+        UINT64_C(0xfffffffffffe001f),
+        UINT64_C(0xfffffffffffe003f),
+        UINT64_C(0xfffffffffffe007f),
+        UINT64_C(0xfffffffffffe00ff),
+        UINT64_C(0xfffffffffffe01ff),
+        UINT64_C(0xfffffffffffe03ff),
+        UINT64_C(0xfffffffffffe07ff),
+        UINT64_C(0xfffffffffffe0fff),
+        UINT64_C(0xfffffffffffe1fff),
+        UINT64_C(0xfffffffffffe3fff),
+        UINT64_C(0xfffffffffffe7fff),
+        UINT64_C(0xfffffffffffeffff)
+    },
+    {
+        UINT64_C(0xfffffffffffc0000),
+        UINT64_C(0xfffffffffffc0001),
+        UINT64_C(0xfffffffffffc0003),
+        UINT64_C(0xfffffffffffc0007),
+        UINT64_C(0xfffffffffffc000f),
+        UINT64_C(0xfffffffffffc001f),
+        UINT64_C(0xfffffffffffc003f),
+        UINT64_C(0xfffffffffffc007f),
+        UINT64_C(0xfffffffffffc00ff),
+        UINT64_C(0xfffffffffffc01ff),
+        UINT64_C(0xfffffffffffc03ff),
+        UINT64_C(0xfffffffffffc07ff),
+        UINT64_C(0xfffffffffffc0fff),
+        UINT64_C(0xfffffffffffc1fff),
+        UINT64_C(0xfffffffffffc3fff),
+        UINT64_C(0xfffffffffffc7fff),
+        UINT64_C(0xfffffffffffcffff),
+        UINT64_C(0xfffffffffffdffff)
+    },
+    {
+        UINT64_C(0xfffffffffff80000),
+        UINT64_C(0xfffffffffff80001),
+        UINT64_C(0xfffffffffff80003),
+        UINT64_C(0xfffffffffff80007),
+        UINT64_C(0xfffffffffff8000f),
+        UINT64_C(0xfffffffffff8001f),
+        UINT64_C(0xfffffffffff8003f),
+        UINT64_C(0xfffffffffff8007f),
+        UINT64_C(0xfffffffffff800ff),
+        UINT64_C(0xfffffffffff801ff),
+        UINT64_C(0xfffffffffff803ff),
+        UINT64_C(0xfffffffffff807ff),
+        UINT64_C(0xfffffffffff80fff),
+        UINT64_C(0xfffffffffff81fff),
+        UINT64_C(0xfffffffffff83fff),
+        UINT64_C(0xfffffffffff87fff),
+        UINT64_C(0xfffffffffff8ffff),
+        UINT64_C(0xfffffffffff9ffff),
+        UINT64_C(0xfffffffffffbffff)
+    },
+    {
+        UINT64_C(0xfffffffffff00000),
+        UINT64_C(0xfffffffffff00001),
+        UINT64_C(0xfffffffffff00003),
+        UINT64_C(0xfffffffffff00007),
+        UINT64_C(0xfffffffffff0000f),
+        UINT64_C(0xfffffffffff0001f),
+        UINT64_C(0xfffffffffff0003f),
+        UINT64_C(0xfffffffffff0007f),
+        UINT64_C(0xfffffffffff000ff),
+        UINT64_C(0xfffffffffff001ff),
+        UINT64_C(0xfffffffffff003ff),
+        UINT64_C(0xfffffffffff007ff),
+        UINT64_C(0xfffffffffff00fff),
+        UINT64_C(0xfffffffffff01fff),
+        UINT64_C(0xfffffffffff03fff),
+        UINT64_C(0xfffffffffff07fff),
+        UINT64_C(0xfffffffffff0ffff),
+        UINT64_C(0xfffffffffff1ffff),
+        UINT64_C(0xfffffffffff3ffff),
+        UINT64_C(0xfffffffffff7ffff)
+    },
+    {
+        UINT64_C(0xffffffffffe00000),
+        UINT64_C(0xffffffffffe00001),
+        UINT64_C(0xffffffffffe00003),
+        UINT64_C(0xffffffffffe00007),
+        UINT64_C(0xffffffffffe0000f),
+        UINT64_C(0xffffffffffe0001f),
+        UINT64_C(0xffffffffffe0003f),
+        UINT64_C(0xffffffffffe0007f),
+        UINT64_C(0xffffffffffe000ff),
+        UINT64_C(0xffffffffffe001ff),
+        UINT64_C(0xffffffffffe003ff),
+        UINT64_C(0xffffffffffe007ff),
+        UINT64_C(0xffffffffffe00fff),
+        UINT64_C(0xffffffffffe01fff),
+        UINT64_C(0xffffffffffe03fff),
+        UINT64_C(0xffffffffffe07fff),
+        UINT64_C(0xffffffffffe0ffff),
+        UINT64_C(0xffffffffffe1ffff),
+        UINT64_C(0xffffffffffe3ffff),
+        UINT64_C(0xffffffffffe7ffff),
+        UINT64_C(0xffffffffffefffff)
+    },
+    {
+        UINT64_C(0xffffffffffc00000),
+        UINT64_C(0xffffffffffc00001),
+        UINT64_C(0xffffffffffc00003),
+        UINT64_C(0xffffffffffc00007),
+        UINT64_C(0xffffffffffc0000f),
+        UINT64_C(0xffffffffffc0001f),
+        UINT64_C(0xffffffffffc0003f),
+        UINT64_C(0xffffffffffc0007f),
+        UINT64_C(0xffffffffffc000ff),
+        UINT64_C(0xffffffffffc001ff),
+        UINT64_C(0xffffffffffc003ff),
+        UINT64_C(0xffffffffffc007ff),
+        UINT64_C(0xffffffffffc00fff),
+        UINT64_C(0xffffffffffc01fff),
+        UINT64_C(0xffffffffffc03fff),
+        UINT64_C(0xffffffffffc07fff),
+        UINT64_C(0xffffffffffc0ffff),
+        UINT64_C(0xffffffffffc1ffff),
+        UINT64_C(0xffffffffffc3ffff),
+        UINT64_C(0xffffffffffc7ffff),
+        UINT64_C(0xffffffffffcfffff),
+        UINT64_C(0xffffffffffdfffff)
+    },
+    {
+        UINT64_C(0xffffffffff800000),
+        UINT64_C(0xffffffffff800001),
+        UINT64_C(0xffffffffff800003),
+        UINT64_C(0xffffffffff800007),
+        UINT64_C(0xffffffffff80000f),
+        UINT64_C(0xffffffffff80001f),
+        UINT64_C(0xffffffffff80003f),
+        UINT64_C(0xffffffffff80007f),
+        UINT64_C(0xffffffffff8000ff),
+        UINT64_C(0xffffffffff8001ff),
+        UINT64_C(0xffffffffff8003ff),
+        UINT64_C(0xffffffffff8007ff),
+        UINT64_C(0xffffffffff800fff),
+        UINT64_C(0xffffffffff801fff),
+        UINT64_C(0xffffffffff803fff),
+        UINT64_C(0xffffffffff807fff),
+        UINT64_C(0xffffffffff80ffff),
+        UINT64_C(0xffffffffff81ffff),
+        UINT64_C(0xffffffffff83ffff),
+        UINT64_C(0xffffffffff87ffff),
+        UINT64_C(0xffffffffff8fffff),
+        UINT64_C(0xffffffffff9fffff),
+        UINT64_C(0xffffffffffbfffff)
+    },
+    {
+        UINT64_C(0xffffffffff000000),
+        UINT64_C(0xffffffffff000001),
+        UINT64_C(0xffffffffff000003),
+        UINT64_C(0xffffffffff000007),
+        UINT64_C(0xffffffffff00000f),
+        UINT64_C(0xffffffffff00001f),
+        UINT64_C(0xffffffffff00003f),
+        UINT64_C(0xffffffffff00007f),
+        UINT64_C(0xffffffffff0000ff),
+        UINT64_C(0xffffffffff0001ff),
+        UINT64_C(0xffffffffff0003ff),
+        UINT64_C(0xffffffffff0007ff),
+        UINT64_C(0xffffffffff000fff),
+        UINT64_C(0xffffffffff001fff),
+        UINT64_C(0xffffffffff003fff),
+        UINT64_C(0xffffffffff007fff),
+        UINT64_C(0xffffffffff00ffff),
+        UINT64_C(0xffffffffff01ffff),
+        UINT64_C(0xffffffffff03ffff),
+        UINT64_C(0xffffffffff07ffff),
+        UINT64_C(0xffffffffff0fffff),
+        UINT64_C(0xffffffffff1fffff),
+        UINT64_C(0xffffffffff3fffff),
+        UINT64_C(0xffffffffff7fffff)
+    },
+    {
+        UINT64_C(0xfffffffffe000000),
+        UINT64_C(0xfffffffffe000001),
+        UINT64_C(0xfffffffffe000003),
+        UINT64_C(0xfffffffffe000007),
+        UINT64_C(0xfffffffffe00000f),
+        UINT64_C(0xfffffffffe00001f),
+        UINT64_C(0xfffffffffe00003f),
+        UINT64_C(0xfffffffffe00007f),
+        UINT64_C(0xfffffffffe0000ff),
+        UINT64_C(0xfffffffffe0001ff),
+        UINT64_C(0xfffffffffe0003ff),
+        UINT64_C(0xfffffffffe0007ff),
+        UINT64_C(0xfffffffffe000fff),
+        UINT64_C(0xfffffffffe001fff),
+        UINT64_C(0xfffffffffe003fff),
+        UINT64_C(0xfffffffffe007fff),
+        UINT64_C(0xfffffffffe00ffff),
+        UINT64_C(0xfffffffffe01ffff),
+        UINT64_C(0xfffffffffe03ffff),
+        UINT64_C(0xfffffffffe07ffff),
+        UINT64_C(0xfffffffffe0fffff),
+        UINT64_C(0xfffffffffe1fffff),
+        UINT64_C(0xfffffffffe3fffff),
+        UINT64_C(0xfffffffffe7fffff),
+        UINT64_C(0xfffffffffeffffff)
+    },
+    {
+        UINT64_C(0xfffffffffc000000),
+        UINT64_C(0xfffffffffc000001),
+        UINT64_C(0xfffffffffc000003),
+        UINT64_C(0xfffffffffc000007),
+        UINT64_C(0xfffffffffc00000f),
+        UINT64_C(0xfffffffffc00001f),
+        UINT64_C(0xfffffffffc00003f),
+        UINT64_C(0xfffffffffc00007f),
+        UINT64_C(0xfffffffffc0000ff),
+        UINT64_C(0xfffffffffc0001ff),
+        UINT64_C(0xfffffffffc0003ff),
+        UINT64_C(0xfffffffffc0007ff),
+        UINT64_C(0xfffffffffc000fff),
+        UINT64_C(0xfffffffffc001fff),
+        UINT64_C(0xfffffffffc003fff),
+        UINT64_C(0xfffffffffc007fff),
+        UINT64_C(0xfffffffffc00ffff),
+        UINT64_C(0xfffffffffc01ffff),
+        UINT64_C(0xfffffffffc03ffff),
+        UINT64_C(0xfffffffffc07ffff),
+        UINT64_C(0xfffffffffc0fffff),
+        UINT64_C(0xfffffffffc1fffff),
+        UINT64_C(0xfffffffffc3fffff),
+        UINT64_C(0xfffffffffc7fffff),
+        UINT64_C(0xfffffffffcffffff),
+        UINT64_C(0xfffffffffdffffff)
+    },
+    {
+        UINT64_C(0xfffffffff8000000),
+        UINT64_C(0xfffffffff8000001),
+        UINT64_C(0xfffffffff8000003),
+        UINT64_C(0xfffffffff8000007),
+        UINT64_C(0xfffffffff800000f),
+        UINT64_C(0xfffffffff800001f),
+        UINT64_C(0xfffffffff800003f),
+        UINT64_C(0xfffffffff800007f),
+        UINT64_C(0xfffffffff80000ff),
+        UINT64_C(0xfffffffff80001ff),
+        UINT64_C(0xfffffffff80003ff),
+        UINT64_C(0xfffffffff80007ff),
+        UINT64_C(0xfffffffff8000fff),
+        UINT64_C(0xfffffffff8001fff),
+        UINT64_C(0xfffffffff8003fff),
+        UINT64_C(0xfffffffff8007fff),
+        UINT64_C(0xfffffffff800ffff),
+        UINT64_C(0xfffffffff801ffff),
+        UINT64_C(0xfffffffff803ffff),
+        UINT64_C(0xfffffffff807ffff),
+        UINT64_C(0xfffffffff80fffff),
+        UINT64_C(0xfffffffff81fffff),
+        UINT64_C(0xfffffffff83fffff),
+        UINT64_C(0xfffffffff87fffff),
+        UINT64_C(0xfffffffff8ffffff),
+        UINT64_C(0xfffffffff9ffffff),
+        UINT64_C(0xfffffffffbffffff)
+    },
+    {
+        UINT64_C(0xfffffffff0000000),
+        UINT64_C(0xfffffffff0000001),
+        UINT64_C(0xfffffffff0000003),
+        UINT64_C(0xfffffffff0000007),
+        UINT64_C(0xfffffffff000000f),
+        UINT64_C(0xfffffffff000001f),
+        UINT64_C(0xfffffffff000003f),
+        UINT64_C(0xfffffffff000007f),
+        UINT64_C(0xfffffffff00000ff),
+        UINT64_C(0xfffffffff00001ff),
+        UINT64_C(0xfffffffff00003ff),
+        UINT64_C(0xfffffffff00007ff),
+        UINT64_C(0xfffffffff0000fff),
+        UINT64_C(0xfffffffff0001fff),
+        UINT64_C(0xfffffffff0003fff),
+        UINT64_C(0xfffffffff0007fff),
+        UINT64_C(0xfffffffff000ffff),
+        UINT64_C(0xfffffffff001ffff),
+        UINT64_C(0xfffffffff003ffff),
+        UINT64_C(0xfffffffff007ffff),
+        UINT64_C(0xfffffffff00fffff),
+        UINT64_C(0xfffffffff01fffff),
+        UINT64_C(0xfffffffff03fffff),
+        UINT64_C(0xfffffffff07fffff),
+        UINT64_C(0xfffffffff0ffffff),
+        UINT64_C(0xfffffffff1ffffff),
+        UINT64_C(0xfffffffff3ffffff),
+        UINT64_C(0xfffffffff7ffffff)
+    },
+    {
+        UINT64_C(0xffffffffe0000000),
+        UINT64_C(0xffffffffe0000001),
+        UINT64_C(0xffffffffe0000003),
+        UINT64_C(0xffffffffe0000007),
+        UINT64_C(0xffffffffe000000f),
+        UINT64_C(0xffffffffe000001f),
+        UINT64_C(0xffffffffe000003f),
+        UINT64_C(0xffffffffe000007f),
+        UINT64_C(0xffffffffe00000ff),
+        UINT64_C(0xffffffffe00001ff),
+        UINT64_C(0xffffffffe00003ff),
+        UINT64_C(0xffffffffe00007ff),
+        UINT64_C(0xffffffffe0000fff),
+        UINT64_C(0xffffffffe0001fff),
+        UINT64_C(0xffffffffe0003fff),
+        UINT64_C(0xffffffffe0007fff),
+        UINT64_C(0xffffffffe000ffff),
+        UINT64_C(0xffffffffe001ffff),
+        UINT64_C(0xffffffffe003ffff),
+        UINT64_C(0xffffffffe007ffff),
+        UINT64_C(0xffffffffe00fffff),
+        UINT64_C(0xffffffffe01fffff),
+        UINT64_C(0xffffffffe03fffff),
+        UINT64_C(0xffffffffe07fffff),
+        UINT64_C(0xffffffffe0ffffff),
+        UINT64_C(0xffffffffe1ffffff),
+        UINT64_C(0xffffffffe3ffffff),
+        UINT64_C(0xffffffffe7ffffff),
+        UINT64_C(0xffffffffefffffff)
+    },
+    {
+        UINT64_C(0xffffffffc0000000),
+        UINT64_C(0xffffffffc0000001),
+        UINT64_C(0xffffffffc0000003),
+        UINT64_C(0xffffffffc0000007),
+        UINT64_C(0xffffffffc000000f),
+        UINT64_C(0xffffffffc000001f),
+        UINT64_C(0xffffffffc000003f),
+        UINT64_C(0xffffffffc000007f),
+        UINT64_C(0xffffffffc00000ff),
+        UINT64_C(0xffffffffc00001ff),
+        UINT64_C(0xffffffffc00003ff),
+        UINT64_C(0xffffffffc00007ff),
+        UINT64_C(0xffffffffc0000fff),
+        UINT64_C(0xffffffffc0001fff),
+        UINT64_C(0xffffffffc0003fff),
+        UINT64_C(0xffffffffc0007fff),
+        UINT64_C(0xffffffffc000ffff),
+        UINT64_C(0xffffffffc001ffff),
+        UINT64_C(0xffffffffc003ffff),
+        UINT64_C(0xffffffffc007ffff),
+        UINT64_C(0xffffffffc00fffff),
+        UINT64_C(0xffffffffc01fffff),
+        UINT64_C(0xffffffffc03fffff),
+        UINT64_C(0xffffffffc07fffff),
+        UINT64_C(0xffffffffc0ffffff),
+        UINT64_C(0xffffffffc1ffffff),
+        UINT64_C(0xffffffffc3ffffff),
+        UINT64_C(0xffffffffc7ffffff),
+        UINT64_C(0xffffffffcfffffff),
+        UINT64_C(0xffffffffdfffffff)
+    },
+    {
+        UINT64_C(0xffffffff80000000),
+        UINT64_C(0xffffffff80000001),
+        UINT64_C(0xffffffff80000003),
+        UINT64_C(0xffffffff80000007),
+        UINT64_C(0xffffffff8000000f),
+        UINT64_C(0xffffffff8000001f),
+        UINT64_C(0xffffffff8000003f),
+        UINT64_C(0xffffffff8000007f),
+        UINT64_C(0xffffffff800000ff),
+        UINT64_C(0xffffffff800001ff),
+        UINT64_C(0xffffffff800003ff),
+        UINT64_C(0xffffffff800007ff),
+        UINT64_C(0xffffffff80000fff),
+        UINT64_C(0xffffffff80001fff),
+        UINT64_C(0xffffffff80003fff),
+        UINT64_C(0xffffffff80007fff),
+        UINT64_C(0xffffffff8000ffff),
+        UINT64_C(0xffffffff8001ffff),
+        UINT64_C(0xffffffff8003ffff),
+        UINT64_C(0xffffffff8007ffff),
+        UINT64_C(0xffffffff800fffff),
+        UINT64_C(0xffffffff801fffff),
+        UINT64_C(0xffffffff803fffff),
+        UINT64_C(0xffffffff807fffff),
+        UINT64_C(0xffffffff80ffffff),
+        UINT64_C(0xffffffff81ffffff),
+        UINT64_C(0xffffffff83ffffff),
+        UINT64_C(0xffffffff87ffffff),
+        UINT64_C(0xffffffff8fffffff),
+        UINT64_C(0xffffffff9fffffff),
+        UINT64_C(0xffffffffbfffffff)
+    },
+    {
+        UINT64_C(0xffffffff00000000),
+        UINT64_C(0xffffffff00000001),
+        UINT64_C(0xffffffff00000003),
+        UINT64_C(0xffffffff00000007),
+        UINT64_C(0xffffffff0000000f),
+        UINT64_C(0xffffffff0000001f),
+        UINT64_C(0xffffffff0000003f),
+        UINT64_C(0xffffffff0000007f),
+        UINT64_C(0xffffffff000000ff),
+        UINT64_C(0xffffffff000001ff),
+        UINT64_C(0xffffffff000003ff),
+        UINT64_C(0xffffffff000007ff),
+        UINT64_C(0xffffffff00000fff),
+        UINT64_C(0xffffffff00001fff),
+        UINT64_C(0xffffffff00003fff),
+        UINT64_C(0xffffffff00007fff),
+        UINT64_C(0xffffffff0000ffff),
+        UINT64_C(0xffffffff0001ffff),
+        UINT64_C(0xffffffff0003ffff),
+        UINT64_C(0xffffffff0007ffff),
+        UINT64_C(0xffffffff000fffff),
+        UINT64_C(0xffffffff001fffff),
+        UINT64_C(0xffffffff003fffff),
+        UINT64_C(0xffffffff007fffff),
+        UINT64_C(0xffffffff00ffffff),
+        UINT64_C(0xffffffff01ffffff),
+        UINT64_C(0xffffffff03ffffff),
+        UINT64_C(0xffffffff07ffffff),
+        UINT64_C(0xffffffff0fffffff),
+        UINT64_C(0xffffffff1fffffff),
+        UINT64_C(0xffffffff3fffffff),
+        UINT64_C(0xffffffff7fffffff)
+    },
+    {
+        UINT64_C(0xfffffffe00000000),
+        UINT64_C(0xfffffffe00000001),
+        UINT64_C(0xfffffffe00000003),
+        UINT64_C(0xfffffffe00000007),
+        UINT64_C(0xfffffffe0000000f),
+        UINT64_C(0xfffffffe0000001f),
+        UINT64_C(0xfffffffe0000003f),
+        UINT64_C(0xfffffffe0000007f),
+        UINT64_C(0xfffffffe000000ff),
+        UINT64_C(0xfffffffe000001ff),
+        UINT64_C(0xfffffffe000003ff),
+        UINT64_C(0xfffffffe000007ff),
+        UINT64_C(0xfffffffe00000fff),
+        UINT64_C(0xfffffffe00001fff),
+        UINT64_C(0xfffffffe00003fff),
+        UINT64_C(0xfffffffe00007fff),
+        UINT64_C(0xfffffffe0000ffff),
+        UINT64_C(0xfffffffe0001ffff),
+        UINT64_C(0xfffffffe0003ffff),
+        UINT64_C(0xfffffffe0007ffff),
+        UINT64_C(0xfffffffe000fffff),
+        UINT64_C(0xfffffffe001fffff),
+        UINT64_C(0xfffffffe003fffff),
+        UINT64_C(0xfffffffe007fffff),
+        UINT64_C(0xfffffffe00ffffff),
+        UINT64_C(0xfffffffe01ffffff),
+        UINT64_C(0xfffffffe03ffffff),
+        UINT64_C(0xfffffffe07ffffff),
+        UINT64_C(0xfffffffe0fffffff),
+        UINT64_C(0xfffffffe1fffffff),
+        UINT64_C(0xfffffffe3fffffff),
+        UINT64_C(0xfffffffe7fffffff),
+        UINT64_C(0xfffffffeffffffff)
+    },
+    {
+        UINT64_C(0xfffffffc00000000),
+        UINT64_C(0xfffffffc00000001),
+        UINT64_C(0xfffffffc00000003),
+        UINT64_C(0xfffffffc00000007),
+        UINT64_C(0xfffffffc0000000f),
+        UINT64_C(0xfffffffc0000001f),
+        UINT64_C(0xfffffffc0000003f),
+        UINT64_C(0xfffffffc0000007f),
+        UINT64_C(0xfffffffc000000ff),
+        UINT64_C(0xfffffffc000001ff),
+        UINT64_C(0xfffffffc000003ff),
+        UINT64_C(0xfffffffc000007ff),
+        UINT64_C(0xfffffffc00000fff),
+        UINT64_C(0xfffffffc00001fff),
+        UINT64_C(0xfffffffc00003fff),
+        UINT64_C(0xfffffffc00007fff),
+        UINT64_C(0xfffffffc0000ffff),
+        UINT64_C(0xfffffffc0001ffff),
+        UINT64_C(0xfffffffc0003ffff),
+        UINT64_C(0xfffffffc0007ffff),
+        UINT64_C(0xfffffffc000fffff),
+        UINT64_C(0xfffffffc001fffff),
+        UINT64_C(0xfffffffc003fffff),
+        UINT64_C(0xfffffffc007fffff),
+        UINT64_C(0xfffffffc00ffffff),
+        UINT64_C(0xfffffffc01ffffff),
+        UINT64_C(0xfffffffc03ffffff),
+        UINT64_C(0xfffffffc07ffffff),
+        UINT64_C(0xfffffffc0fffffff),
+        UINT64_C(0xfffffffc1fffffff),
+        UINT64_C(0xfffffffc3fffffff),
+        UINT64_C(0xfffffffc7fffffff),
+        UINT64_C(0xfffffffcffffffff),
+        UINT64_C(0xfffffffdffffffff)
+    },
+    {
+        UINT64_C(0xfffffff800000000),
+        UINT64_C(0xfffffff800000001),
+        UINT64_C(0xfffffff800000003),
+        UINT64_C(0xfffffff800000007),
+        UINT64_C(0xfffffff80000000f),
+        UINT64_C(0xfffffff80000001f),
+        UINT64_C(0xfffffff80000003f),
+        UINT64_C(0xfffffff80000007f),
+        UINT64_C(0xfffffff8000000ff),
+        UINT64_C(0xfffffff8000001ff),
+        UINT64_C(0xfffffff8000003ff),
+        UINT64_C(0xfffffff8000007ff),
+        UINT64_C(0xfffffff800000fff),
+        UINT64_C(0xfffffff800001fff),
+        UINT64_C(0xfffffff800003fff),
+        UINT64_C(0xfffffff800007fff),
+        UINT64_C(0xfffffff80000ffff),
+        UINT64_C(0xfffffff80001ffff),
+        UINT64_C(0xfffffff80003ffff),
+        UINT64_C(0xfffffff80007ffff),
+        UINT64_C(0xfffffff8000fffff),
+        UINT64_C(0xfffffff8001fffff),
+        UINT64_C(0xfffffff8003fffff),
+        UINT64_C(0xfffffff8007fffff),
+        UINT64_C(0xfffffff800ffffff),
+        UINT64_C(0xfffffff801ffffff),
+        UINT64_C(0xfffffff803ffffff),
+        UINT64_C(0xfffffff807ffffff),
+        UINT64_C(0xfffffff80fffffff),
+        UINT64_C(0xfffffff81fffffff),
+        UINT64_C(0xfffffff83fffffff),
+        UINT64_C(0xfffffff87fffffff),
+        UINT64_C(0xfffffff8ffffffff),
+        UINT64_C(0xfffffff9ffffffff),
+        UINT64_C(0xfffffffbffffffff)
+    },
+    {
+        UINT64_C(0xfffffff000000000),
+        UINT64_C(0xfffffff000000001),
+        UINT64_C(0xfffffff000000003),
+        UINT64_C(0xfffffff000000007),
+        UINT64_C(0xfffffff00000000f),
+        UINT64_C(0xfffffff00000001f),
+        UINT64_C(0xfffffff00000003f),
+        UINT64_C(0xfffffff00000007f),
+        UINT64_C(0xfffffff0000000ff),
+        UINT64_C(0xfffffff0000001ff),
+        UINT64_C(0xfffffff0000003ff),
+        UINT64_C(0xfffffff0000007ff),
+        UINT64_C(0xfffffff000000fff),
+        UINT64_C(0xfffffff000001fff),
+        UINT64_C(0xfffffff000003fff),
+        UINT64_C(0xfffffff000007fff),
+        UINT64_C(0xfffffff00000ffff),
+        UINT64_C(0xfffffff00001ffff),
+        UINT64_C(0xfffffff00003ffff),
+        UINT64_C(0xfffffff00007ffff),
+        UINT64_C(0xfffffff0000fffff),
+        UINT64_C(0xfffffff0001fffff),
+        UINT64_C(0xfffffff0003fffff),
+        UINT64_C(0xfffffff0007fffff),
+        UINT64_C(0xfffffff000ffffff),
+        UINT64_C(0xfffffff001ffffff),
+        UINT64_C(0xfffffff003ffffff),
+        UINT64_C(0xfffffff007ffffff),
+        UINT64_C(0xfffffff00fffffff),
+        UINT64_C(0xfffffff01fffffff),
+        UINT64_C(0xfffffff03fffffff),
+        UINT64_C(0xfffffff07fffffff),
+        UINT64_C(0xfffffff0ffffffff),
+        UINT64_C(0xfffffff1ffffffff),
+        UINT64_C(0xfffffff3ffffffff),
+        UINT64_C(0xfffffff7ffffffff)
+    },
+    {
+        UINT64_C(0xffffffe000000000),
+        UINT64_C(0xffffffe000000001),
+        UINT64_C(0xffffffe000000003),
+        UINT64_C(0xffffffe000000007),
+        UINT64_C(0xffffffe00000000f),
+        UINT64_C(0xffffffe00000001f),
+        UINT64_C(0xffffffe00000003f),
+        UINT64_C(0xffffffe00000007f),
+        UINT64_C(0xffffffe0000000ff),
+        UINT64_C(0xffffffe0000001ff),
+        UINT64_C(0xffffffe0000003ff),
+        UINT64_C(0xffffffe0000007ff),
+        UINT64_C(0xffffffe000000fff),
+        UINT64_C(0xffffffe000001fff),
+        UINT64_C(0xffffffe000003fff),
+        UINT64_C(0xffffffe000007fff),
+        UINT64_C(0xffffffe00000ffff),
+        UINT64_C(0xffffffe00001ffff),
+        UINT64_C(0xffffffe00003ffff),
+        UINT64_C(0xffffffe00007ffff),
+        UINT64_C(0xffffffe0000fffff),
+        UINT64_C(0xffffffe0001fffff),
+        UINT64_C(0xffffffe0003fffff),
+        UINT64_C(0xffffffe0007fffff),
+        UINT64_C(0xffffffe000ffffff),
+        UINT64_C(0xffffffe001ffffff),
+        UINT64_C(0xffffffe003ffffff),
+        UINT64_C(0xffffffe007ffffff),
+        UINT64_C(0xffffffe00fffffff),
+        UINT64_C(0xffffffe01fffffff),
+        UINT64_C(0xffffffe03fffffff),
+        UINT64_C(0xffffffe07fffffff),
+        UINT64_C(0xffffffe0ffffffff),
+        UINT64_C(0xffffffe1ffffffff),
+        UINT64_C(0xffffffe3ffffffff),
+        UINT64_C(0xffffffe7ffffffff),
+        UINT64_C(0xffffffefffffffff)
+    },
+    {
+        UINT64_C(0xffffffc000000000),
+        UINT64_C(0xffffffc000000001),
+        UINT64_C(0xffffffc000000003),
+        UINT64_C(0xffffffc000000007),
+        UINT64_C(0xffffffc00000000f),
+        UINT64_C(0xffffffc00000001f),
+        UINT64_C(0xffffffc00000003f),
+        UINT64_C(0xffffffc00000007f),
+        UINT64_C(0xffffffc0000000ff),
+        UINT64_C(0xffffffc0000001ff),
+        UINT64_C(0xffffffc0000003ff),
+        UINT64_C(0xffffffc0000007ff),
+        UINT64_C(0xffffffc000000fff),
+        UINT64_C(0xffffffc000001fff),
+        UINT64_C(0xffffffc000003fff),
+        UINT64_C(0xffffffc000007fff),
+        UINT64_C(0xffffffc00000ffff),
+        UINT64_C(0xffffffc00001ffff),
+        UINT64_C(0xffffffc00003ffff),
+        UINT64_C(0xffffffc00007ffff),
+        UINT64_C(0xffffffc0000fffff),
+        UINT64_C(0xffffffc0001fffff),
+        UINT64_C(0xffffffc0003fffff),
+        UINT64_C(0xffffffc0007fffff),
+        UINT64_C(0xffffffc000ffffff),
+        UINT64_C(0xffffffc001ffffff),
+        UINT64_C(0xffffffc003ffffff),
+        UINT64_C(0xffffffc007ffffff),
+        UINT64_C(0xffffffc00fffffff),
+        UINT64_C(0xffffffc01fffffff),
+        UINT64_C(0xffffffc03fffffff),
+        UINT64_C(0xffffffc07fffffff),
+        UINT64_C(0xffffffc0ffffffff),
+        UINT64_C(0xffffffc1ffffffff),
+        UINT64_C(0xffffffc3ffffffff),
+        UINT64_C(0xffffffc7ffffffff),
+        UINT64_C(0xffffffcfffffffff),
+        UINT64_C(0xffffffdfffffffff)
+    },
+    {
+        UINT64_C(0xffffff8000000000),
+        UINT64_C(0xffffff8000000001),
+        UINT64_C(0xffffff8000000003),
+        UINT64_C(0xffffff8000000007),
+        UINT64_C(0xffffff800000000f),
+        UINT64_C(0xffffff800000001f),
+        UINT64_C(0xffffff800000003f),
+        UINT64_C(0xffffff800000007f),
+        UINT64_C(0xffffff80000000ff),
+        UINT64_C(0xffffff80000001ff),
+        UINT64_C(0xffffff80000003ff),
+        UINT64_C(0xffffff80000007ff),
+        UINT64_C(0xffffff8000000fff),
+        UINT64_C(0xffffff8000001fff),
+        UINT64_C(0xffffff8000003fff),
+        UINT64_C(0xffffff8000007fff),
+        UINT64_C(0xffffff800000ffff),
+        UINT64_C(0xffffff800001ffff),
+        UINT64_C(0xffffff800003ffff),
+        UINT64_C(0xffffff800007ffff),
+        UINT64_C(0xffffff80000fffff),
+        UINT64_C(0xffffff80001fffff),
+        UINT64_C(0xffffff80003fffff),
+        UINT64_C(0xffffff80007fffff),
+        UINT64_C(0xffffff8000ffffff),
+        UINT64_C(0xffffff8001ffffff),
+        UINT64_C(0xffffff8003ffffff),
+        UINT64_C(0xffffff8007ffffff),
+        UINT64_C(0xffffff800fffffff),
+        UINT64_C(0xffffff801fffffff),
+        UINT64_C(0xffffff803fffffff),
+        UINT64_C(0xffffff807fffffff),
+        UINT64_C(0xffffff80ffffffff),
+        UINT64_C(0xffffff81ffffffff),
+        UINT64_C(0xffffff83ffffffff),
+        UINT64_C(0xffffff87ffffffff),
+        UINT64_C(0xffffff8fffffffff),
+        UINT64_C(0xffffff9fffffffff),
+        UINT64_C(0xffffffbfffffffff)
+    },
+    {
+        UINT64_C(0xffffff0000000000),
+        UINT64_C(0xffffff0000000001),
+        UINT64_C(0xffffff0000000003),
+        UINT64_C(0xffffff0000000007),
+        UINT64_C(0xffffff000000000f),
+        UINT64_C(0xffffff000000001f),
+        UINT64_C(0xffffff000000003f),
+        UINT64_C(0xffffff000000007f),
+        UINT64_C(0xffffff00000000ff),
+        UINT64_C(0xffffff00000001ff),
+        UINT64_C(0xffffff00000003ff),
+        UINT64_C(0xffffff00000007ff),
+        UINT64_C(0xffffff0000000fff),
+        UINT64_C(0xffffff0000001fff),
+        UINT64_C(0xffffff0000003fff),
+        UINT64_C(0xffffff0000007fff),
+        UINT64_C(0xffffff000000ffff),
+        UINT64_C(0xffffff000001ffff),
+        UINT64_C(0xffffff000003ffff),
+        UINT64_C(0xffffff000007ffff),
+        UINT64_C(0xffffff00000fffff),
+        UINT64_C(0xffffff00001fffff),
+        UINT64_C(0xffffff00003fffff),
+        UINT64_C(0xffffff00007fffff),
+        UINT64_C(0xffffff0000ffffff),
+        UINT64_C(0xffffff0001ffffff),
+        UINT64_C(0xffffff0003ffffff),
+        UINT64_C(0xffffff0007ffffff),
+        UINT64_C(0xffffff000fffffff),
+        UINT64_C(0xffffff001fffffff),
+        UINT64_C(0xffffff003fffffff),
+        UINT64_C(0xffffff007fffffff),
+        UINT64_C(0xffffff00ffffffff),
+        UINT64_C(0xffffff01ffffffff),
+        UINT64_C(0xffffff03ffffffff),
+        UINT64_C(0xffffff07ffffffff),
+        UINT64_C(0xffffff0fffffffff),
+        UINT64_C(0xffffff1fffffffff),
+        UINT64_C(0xffffff3fffffffff),
+        UINT64_C(0xffffff7fffffffff)
+    },
+    {
+        UINT64_C(0xfffffe0000000000),
+        UINT64_C(0xfffffe0000000001),
+        UINT64_C(0xfffffe0000000003),
+        UINT64_C(0xfffffe0000000007),
+        UINT64_C(0xfffffe000000000f),
+        UINT64_C(0xfffffe000000001f),
+        UINT64_C(0xfffffe000000003f),
+        UINT64_C(0xfffffe000000007f),
+        UINT64_C(0xfffffe00000000ff),
+        UINT64_C(0xfffffe00000001ff),
+        UINT64_C(0xfffffe00000003ff),
+        UINT64_C(0xfffffe00000007ff),
+        UINT64_C(0xfffffe0000000fff),
+        UINT64_C(0xfffffe0000001fff),
+        UINT64_C(0xfffffe0000003fff),
+        UINT64_C(0xfffffe0000007fff),
+        UINT64_C(0xfffffe000000ffff),
+        UINT64_C(0xfffffe000001ffff),
+        UINT64_C(0xfffffe000003ffff),
+        UINT64_C(0xfffffe000007ffff),
+        UINT64_C(0xfffffe00000fffff),
+        UINT64_C(0xfffffe00001fffff),
+        UINT64_C(0xfffffe00003fffff),
+        UINT64_C(0xfffffe00007fffff),
+        UINT64_C(0xfffffe0000ffffff),
+        UINT64_C(0xfffffe0001ffffff),
+        UINT64_C(0xfffffe0003ffffff),
+        UINT64_C(0xfffffe0007ffffff),
+        UINT64_C(0xfffffe000fffffff),
+        UINT64_C(0xfffffe001fffffff),
+        UINT64_C(0xfffffe003fffffff),
+        UINT64_C(0xfffffe007fffffff),
+        UINT64_C(0xfffffe00ffffffff),
+        UINT64_C(0xfffffe01ffffffff),
+        UINT64_C(0xfffffe03ffffffff),
+        UINT64_C(0xfffffe07ffffffff),
+        UINT64_C(0xfffffe0fffffffff),
+        UINT64_C(0xfffffe1fffffffff),
+        UINT64_C(0xfffffe3fffffffff),
+        UINT64_C(0xfffffe7fffffffff),
+        UINT64_C(0xfffffeffffffffff)
+    },
+    {
+        UINT64_C(0xfffffc0000000000),
+        UINT64_C(0xfffffc0000000001),
+        UINT64_C(0xfffffc0000000003),
+        UINT64_C(0xfffffc0000000007),
+        UINT64_C(0xfffffc000000000f),
+        UINT64_C(0xfffffc000000001f),
+        UINT64_C(0xfffffc000000003f),
+        UINT64_C(0xfffffc000000007f),
+        UINT64_C(0xfffffc00000000ff),
+        UINT64_C(0xfffffc00000001ff),
+        UINT64_C(0xfffffc00000003ff),
+        UINT64_C(0xfffffc00000007ff),
+        UINT64_C(0xfffffc0000000fff),
+        UINT64_C(0xfffffc0000001fff),
+        UINT64_C(0xfffffc0000003fff),
+        UINT64_C(0xfffffc0000007fff),
+        UINT64_C(0xfffffc000000ffff),
+        UINT64_C(0xfffffc000001ffff),
+        UINT64_C(0xfffffc000003ffff),
+        UINT64_C(0xfffffc000007ffff),
+        UINT64_C(0xfffffc00000fffff),
+        UINT64_C(0xfffffc00001fffff),
+        UINT64_C(0xfffffc00003fffff),
+        UINT64_C(0xfffffc00007fffff),
+        UINT64_C(0xfffffc0000ffffff),
+        UINT64_C(0xfffffc0001ffffff),
+        UINT64_C(0xfffffc0003ffffff),
+        UINT64_C(0xfffffc0007ffffff),
+        UINT64_C(0xfffffc000fffffff),
+        UINT64_C(0xfffffc001fffffff),
+        UINT64_C(0xfffffc003fffffff),
+        UINT64_C(0xfffffc007fffffff),
+        UINT64_C(0xfffffc00ffffffff),
+        UINT64_C(0xfffffc01ffffffff),
+        UINT64_C(0xfffffc03ffffffff),
+        UINT64_C(0xfffffc07ffffffff),
+        UINT64_C(0xfffffc0fffffffff),
+        UINT64_C(0xfffffc1fffffffff),
+        UINT64_C(0xfffffc3fffffffff),
+        UINT64_C(0xfffffc7fffffffff),
+        UINT64_C(0xfffffcffffffffff),
+        UINT64_C(0xfffffdffffffffff)
+    },
+    {
+        UINT64_C(0xfffff80000000000),
+        UINT64_C(0xfffff80000000001),
+        UINT64_C(0xfffff80000000003),
+        UINT64_C(0xfffff80000000007),
+        UINT64_C(0xfffff8000000000f),
+        UINT64_C(0xfffff8000000001f),
+        UINT64_C(0xfffff8000000003f),
+        UINT64_C(0xfffff8000000007f),
+        UINT64_C(0xfffff800000000ff),
+        UINT64_C(0xfffff800000001ff),
+        UINT64_C(0xfffff800000003ff),
+        UINT64_C(0xfffff800000007ff),
+        UINT64_C(0xfffff80000000fff),
+        UINT64_C(0xfffff80000001fff),
+        UINT64_C(0xfffff80000003fff),
+        UINT64_C(0xfffff80000007fff),
+        UINT64_C(0xfffff8000000ffff),
+        UINT64_C(0xfffff8000001ffff),
+        UINT64_C(0xfffff8000003ffff),
+        UINT64_C(0xfffff8000007ffff),
+        UINT64_C(0xfffff800000fffff),
+        UINT64_C(0xfffff800001fffff),
+        UINT64_C(0xfffff800003fffff),
+        UINT64_C(0xfffff800007fffff),
+        UINT64_C(0xfffff80000ffffff),
+        UINT64_C(0xfffff80001ffffff),
+        UINT64_C(0xfffff80003ffffff),
+        UINT64_C(0xfffff80007ffffff),
+        UINT64_C(0xfffff8000fffffff),
+        UINT64_C(0xfffff8001fffffff),
+        UINT64_C(0xfffff8003fffffff),
+        UINT64_C(0xfffff8007fffffff),
+        UINT64_C(0xfffff800ffffffff),
+        UINT64_C(0xfffff801ffffffff),
+        UINT64_C(0xfffff803ffffffff),
+        UINT64_C(0xfffff807ffffffff),
+        UINT64_C(0xfffff80fffffffff),
+        UINT64_C(0xfffff81fffffffff),
+        UINT64_C(0xfffff83fffffffff),
+        UINT64_C(0xfffff87fffffffff),
+        UINT64_C(0xfffff8ffffffffff),
+        UINT64_C(0xfffff9ffffffffff),
+        UINT64_C(0xfffffbffffffffff)
+    },
+    {
+        UINT64_C(0xfffff00000000000),
+        UINT64_C(0xfffff00000000001),
+        UINT64_C(0xfffff00000000003),
+        UINT64_C(0xfffff00000000007),
+        UINT64_C(0xfffff0000000000f),
+        UINT64_C(0xfffff0000000001f),
+        UINT64_C(0xfffff0000000003f),
+        UINT64_C(0xfffff0000000007f),
+        UINT64_C(0xfffff000000000ff),
+        UINT64_C(0xfffff000000001ff),
+        UINT64_C(0xfffff000000003ff),
+        UINT64_C(0xfffff000000007ff),
+        UINT64_C(0xfffff00000000fff),
+        UINT64_C(0xfffff00000001fff),
+        UINT64_C(0xfffff00000003fff),
+        UINT64_C(0xfffff00000007fff),
+        UINT64_C(0xfffff0000000ffff),
+        UINT64_C(0xfffff0000001ffff),
+        UINT64_C(0xfffff0000003ffff),
+        UINT64_C(0xfffff0000007ffff),
+        UINT64_C(0xfffff000000fffff),
+        UINT64_C(0xfffff000001fffff),
+        UINT64_C(0xfffff000003fffff),
+        UINT64_C(0xfffff000007fffff),
+        UINT64_C(0xfffff00000ffffff),
+        UINT64_C(0xfffff00001ffffff),
+        UINT64_C(0xfffff00003ffffff),
+        UINT64_C(0xfffff00007ffffff),
+        UINT64_C(0xfffff0000fffffff),
+        UINT64_C(0xfffff0001fffffff),
+        UINT64_C(0xfffff0003fffffff),
+        UINT64_C(0xfffff0007fffffff),
+        UINT64_C(0xfffff000ffffffff),
+        UINT64_C(0xfffff001ffffffff),
+        UINT64_C(0xfffff003ffffffff),
+        UINT64_C(0xfffff007ffffffff),
+        UINT64_C(0xfffff00fffffffff),
+        UINT64_C(0xfffff01fffffffff),
+        UINT64_C(0xfffff03fffffffff),
+        UINT64_C(0xfffff07fffffffff),
+        UINT64_C(0xfffff0ffffffffff),
+        UINT64_C(0xfffff1ffffffffff),
+        UINT64_C(0xfffff3ffffffffff),
+        UINT64_C(0xfffff7ffffffffff)
+    },
+    {
+        UINT64_C(0xffffe00000000000),
+        UINT64_C(0xffffe00000000001),
+        UINT64_C(0xffffe00000000003),
+        UINT64_C(0xffffe00000000007),
+        UINT64_C(0xffffe0000000000f),
+        UINT64_C(0xffffe0000000001f),
+        UINT64_C(0xffffe0000000003f),
+        UINT64_C(0xffffe0000000007f),
+        UINT64_C(0xffffe000000000ff),
+        UINT64_C(0xffffe000000001ff),
+        UINT64_C(0xffffe000000003ff),
+        UINT64_C(0xffffe000000007ff),
+        UINT64_C(0xffffe00000000fff),
+        UINT64_C(0xffffe00000001fff),
+        UINT64_C(0xffffe00000003fff),
+        UINT64_C(0xffffe00000007fff),
+        UINT64_C(0xffffe0000000ffff),
+        UINT64_C(0xffffe0000001ffff),
+        UINT64_C(0xffffe0000003ffff),
+        UINT64_C(0xffffe0000007ffff),
+        UINT64_C(0xffffe000000fffff),
+        UINT64_C(0xffffe000001fffff),
+        UINT64_C(0xffffe000003fffff),
+        UINT64_C(0xffffe000007fffff),
+        UINT64_C(0xffffe00000ffffff),
+        UINT64_C(0xffffe00001ffffff),
+        UINT64_C(0xffffe00003ffffff),
+        UINT64_C(0xffffe00007ffffff),
+        UINT64_C(0xffffe0000fffffff),
+        UINT64_C(0xffffe0001fffffff),
+        UINT64_C(0xffffe0003fffffff),
+        UINT64_C(0xffffe0007fffffff),
+        UINT64_C(0xffffe000ffffffff),
+        UINT64_C(0xffffe001ffffffff),
+        UINT64_C(0xffffe003ffffffff),
+        UINT64_C(0xffffe007ffffffff),
+        UINT64_C(0xffffe00fffffffff),
+        UINT64_C(0xffffe01fffffffff),
+        UINT64_C(0xffffe03fffffffff),
+        UINT64_C(0xffffe07fffffffff),
+        UINT64_C(0xffffe0ffffffffff),
+        UINT64_C(0xffffe1ffffffffff),
+        UINT64_C(0xffffe3ffffffffff),
+        UINT64_C(0xffffe7ffffffffff),
+        UINT64_C(0xffffefffffffffff)
+    },
+    {
+        UINT64_C(0xffffc00000000000),
+        UINT64_C(0xffffc00000000001),
+        UINT64_C(0xffffc00000000003),
+        UINT64_C(0xffffc00000000007),
+        UINT64_C(0xffffc0000000000f),
+        UINT64_C(0xffffc0000000001f),
+        UINT64_C(0xffffc0000000003f),
+        UINT64_C(0xffffc0000000007f),
+        UINT64_C(0xffffc000000000ff),
+        UINT64_C(0xffffc000000001ff),
+        UINT64_C(0xffffc000000003ff),
+        UINT64_C(0xffffc000000007ff),
+        UINT64_C(0xffffc00000000fff),
+        UINT64_C(0xffffc00000001fff),
+        UINT64_C(0xffffc00000003fff),
+        UINT64_C(0xffffc00000007fff),
+        UINT64_C(0xffffc0000000ffff),
+        UINT64_C(0xffffc0000001ffff),
+        UINT64_C(0xffffc0000003ffff),
+        UINT64_C(0xffffc0000007ffff),
+        UINT64_C(0xffffc000000fffff),
+        UINT64_C(0xffffc000001fffff),
+        UINT64_C(0xffffc000003fffff),
+        UINT64_C(0xffffc000007fffff),
+        UINT64_C(0xffffc00000ffffff),
+        UINT64_C(0xffffc00001ffffff),
+        UINT64_C(0xffffc00003ffffff),
+        UINT64_C(0xffffc00007ffffff),
+        UINT64_C(0xffffc0000fffffff),
+        UINT64_C(0xffffc0001fffffff),
+        UINT64_C(0xffffc0003fffffff),
+        UINT64_C(0xffffc0007fffffff),
+        UINT64_C(0xffffc000ffffffff),
+        UINT64_C(0xffffc001ffffffff),
+        UINT64_C(0xffffc003ffffffff),
+        UINT64_C(0xffffc007ffffffff),
+        UINT64_C(0xffffc00fffffffff),
+        UINT64_C(0xffffc01fffffffff),
+        UINT64_C(0xffffc03fffffffff),
+        UINT64_C(0xffffc07fffffffff),
+        UINT64_C(0xffffc0ffffffffff),
+        UINT64_C(0xffffc1ffffffffff),
+        UINT64_C(0xffffc3ffffffffff),
+        UINT64_C(0xffffc7ffffffffff),
+        UINT64_C(0xffffcfffffffffff),
+        UINT64_C(0xffffdfffffffffff)
+    },
+    {
+        UINT64_C(0xffff800000000000),
+        UINT64_C(0xffff800000000001),
+        UINT64_C(0xffff800000000003),
+        UINT64_C(0xffff800000000007),
+        UINT64_C(0xffff80000000000f),
+        UINT64_C(0xffff80000000001f),
+        UINT64_C(0xffff80000000003f),
+        UINT64_C(0xffff80000000007f),
+        UINT64_C(0xffff8000000000ff),
+        UINT64_C(0xffff8000000001ff),
+        UINT64_C(0xffff8000000003ff),
+        UINT64_C(0xffff8000000007ff),
+        UINT64_C(0xffff800000000fff),
+        UINT64_C(0xffff800000001fff),
+        UINT64_C(0xffff800000003fff),
+        UINT64_C(0xffff800000007fff),
+        UINT64_C(0xffff80000000ffff),
+        UINT64_C(0xffff80000001ffff),
+        UINT64_C(0xffff80000003ffff),
+        UINT64_C(0xffff80000007ffff),
+        UINT64_C(0xffff8000000fffff),
+        UINT64_C(0xffff8000001fffff),
+        UINT64_C(0xffff8000003fffff),
+        UINT64_C(0xffff8000007fffff),
+        UINT64_C(0xffff800000ffffff),
+        UINT64_C(0xffff800001ffffff),
+        UINT64_C(0xffff800003ffffff),
+        UINT64_C(0xffff800007ffffff),
+        UINT64_C(0xffff80000fffffff),
+        UINT64_C(0xffff80001fffffff),
+        UINT64_C(0xffff80003fffffff),
+        UINT64_C(0xffff80007fffffff),
+        UINT64_C(0xffff8000ffffffff),
+        UINT64_C(0xffff8001ffffffff),
+        UINT64_C(0xffff8003ffffffff),
+        UINT64_C(0xffff8007ffffffff),
+        UINT64_C(0xffff800fffffffff),
+        UINT64_C(0xffff801fffffffff),
+        UINT64_C(0xffff803fffffffff),
+        UINT64_C(0xffff807fffffffff),
+        UINT64_C(0xffff80ffffffffff),
+        UINT64_C(0xffff81ffffffffff),
+        UINT64_C(0xffff83ffffffffff),
+        UINT64_C(0xffff87ffffffffff),
+        UINT64_C(0xffff8fffffffffff),
+        UINT64_C(0xffff9fffffffffff),
+        UINT64_C(0xffffbfffffffffff)
+    },
+    {
+        UINT64_C(0xffff000000000000),
+        UINT64_C(0xffff000000000001),
+        UINT64_C(0xffff000000000003),
+        UINT64_C(0xffff000000000007),
+        UINT64_C(0xffff00000000000f),
+        UINT64_C(0xffff00000000001f),
+        UINT64_C(0xffff00000000003f),
+        UINT64_C(0xffff00000000007f),
+        UINT64_C(0xffff0000000000ff),
+        UINT64_C(0xffff0000000001ff),
+        UINT64_C(0xffff0000000003ff),
+        UINT64_C(0xffff0000000007ff),
+        UINT64_C(0xffff000000000fff),
+        UINT64_C(0xffff000000001fff),
+        UINT64_C(0xffff000000003fff),
+        UINT64_C(0xffff000000007fff),
+        UINT64_C(0xffff00000000ffff),
+        UINT64_C(0xffff00000001ffff),
+        UINT64_C(0xffff00000003ffff),
+        UINT64_C(0xffff00000007ffff),
+        UINT64_C(0xffff0000000fffff),
+        UINT64_C(0xffff0000001fffff),
+        UINT64_C(0xffff0000003fffff),
+        UINT64_C(0xffff0000007fffff),
+        UINT64_C(0xffff000000ffffff),
+        UINT64_C(0xffff000001ffffff),
+        UINT64_C(0xffff000003ffffff),
+        UINT64_C(0xffff000007ffffff),
+        UINT64_C(0xffff00000fffffff),
+        UINT64_C(0xffff00001fffffff),
+        UINT64_C(0xffff00003fffffff),
+        UINT64_C(0xffff00007fffffff),
+        UINT64_C(0xffff0000ffffffff),
+        UINT64_C(0xffff0001ffffffff),
+        UINT64_C(0xffff0003ffffffff),
+        UINT64_C(0xffff0007ffffffff),
+        UINT64_C(0xffff000fffffffff),
+        UINT64_C(0xffff001fffffffff),
+        UINT64_C(0xffff003fffffffff),
+        UINT64_C(0xffff007fffffffff),
+        UINT64_C(0xffff00ffffffffff),
+        UINT64_C(0xffff01ffffffffff),
+        UINT64_C(0xffff03ffffffffff),
+        UINT64_C(0xffff07ffffffffff),
+        UINT64_C(0xffff0fffffffffff),
+        UINT64_C(0xffff1fffffffffff),
+        UINT64_C(0xffff3fffffffffff),
+        UINT64_C(0xffff7fffffffffff)
+    },
+    {
+        UINT64_C(0xfffe000000000000),
+        UINT64_C(0xfffe000000000001),
+        UINT64_C(0xfffe000000000003),
+        UINT64_C(0xfffe000000000007),
+        UINT64_C(0xfffe00000000000f),
+        UINT64_C(0xfffe00000000001f),
+        UINT64_C(0xfffe00000000003f),
+        UINT64_C(0xfffe00000000007f),
+        UINT64_C(0xfffe0000000000ff),
+        UINT64_C(0xfffe0000000001ff),
+        UINT64_C(0xfffe0000000003ff),
+        UINT64_C(0xfffe0000000007ff),
+        UINT64_C(0xfffe000000000fff),
+        UINT64_C(0xfffe000000001fff),
+        UINT64_C(0xfffe000000003fff),
+        UINT64_C(0xfffe000000007fff),
+        UINT64_C(0xfffe00000000ffff),
+        UINT64_C(0xfffe00000001ffff),
+        UINT64_C(0xfffe00000003ffff),
+        UINT64_C(0xfffe00000007ffff),
+        UINT64_C(0xfffe0000000fffff),
+        UINT64_C(0xfffe0000001fffff),
+        UINT64_C(0xfffe0000003fffff),
+        UINT64_C(0xfffe0000007fffff),
+        UINT64_C(0xfffe000000ffffff),
+        UINT64_C(0xfffe000001ffffff),
+        UINT64_C(0xfffe000003ffffff),
+        UINT64_C(0xfffe000007ffffff),
+        UINT64_C(0xfffe00000fffffff),
+        UINT64_C(0xfffe00001fffffff),
+        UINT64_C(0xfffe00003fffffff),
+        UINT64_C(0xfffe00007fffffff),
+        UINT64_C(0xfffe0000ffffffff),
+        UINT64_C(0xfffe0001ffffffff),
+        UINT64_C(0xfffe0003ffffffff),
+        UINT64_C(0xfffe0007ffffffff),
+        UINT64_C(0xfffe000fffffffff),
+        UINT64_C(0xfffe001fffffffff),
+        UINT64_C(0xfffe003fffffffff),
+        UINT64_C(0xfffe007fffffffff),
+        UINT64_C(0xfffe00ffffffffff),
+        UINT64_C(0xfffe01ffffffffff),
+        UINT64_C(0xfffe03ffffffffff),
+        UINT64_C(0xfffe07ffffffffff),
+        UINT64_C(0xfffe0fffffffffff),
+        UINT64_C(0xfffe1fffffffffff),
+        UINT64_C(0xfffe3fffffffffff),
+        UINT64_C(0xfffe7fffffffffff),
+        UINT64_C(0xfffeffffffffffff)
+    },
+    {
+        UINT64_C(0xfffc000000000000),
+        UINT64_C(0xfffc000000000001),
+        UINT64_C(0xfffc000000000003),
+        UINT64_C(0xfffc000000000007),
+        UINT64_C(0xfffc00000000000f),
+        UINT64_C(0xfffc00000000001f),
+        UINT64_C(0xfffc00000000003f),
+        UINT64_C(0xfffc00000000007f),
+        UINT64_C(0xfffc0000000000ff),
+        UINT64_C(0xfffc0000000001ff),
+        UINT64_C(0xfffc0000000003ff),
+        UINT64_C(0xfffc0000000007ff),
+        UINT64_C(0xfffc000000000fff),
+        UINT64_C(0xfffc000000001fff),
+        UINT64_C(0xfffc000000003fff),
+        UINT64_C(0xfffc000000007fff),
+        UINT64_C(0xfffc00000000ffff),
+        UINT64_C(0xfffc00000001ffff),
+        UINT64_C(0xfffc00000003ffff),
+        UINT64_C(0xfffc00000007ffff),
+        UINT64_C(0xfffc0000000fffff),
+        UINT64_C(0xfffc0000001fffff),
+        UINT64_C(0xfffc0000003fffff),
+        UINT64_C(0xfffc0000007fffff),
+        UINT64_C(0xfffc000000ffffff),
+        UINT64_C(0xfffc000001ffffff),
+        UINT64_C(0xfffc000003ffffff),
+        UINT64_C(0xfffc000007ffffff),
+        UINT64_C(0xfffc00000fffffff),
+        UINT64_C(0xfffc00001fffffff),
+        UINT64_C(0xfffc00003fffffff),
+        UINT64_C(0xfffc00007fffffff),
+        UINT64_C(0xfffc0000ffffffff),
+        UINT64_C(0xfffc0001ffffffff),
+        UINT64_C(0xfffc0003ffffffff),
+        UINT64_C(0xfffc0007ffffffff),
+        UINT64_C(0xfffc000fffffffff),
+        UINT64_C(0xfffc001fffffffff),
+        UINT64_C(0xfffc003fffffffff),
+        UINT64_C(0xfffc007fffffffff),
+        UINT64_C(0xfffc00ffffffffff),
+        UINT64_C(0xfffc01ffffffffff),
+        UINT64_C(0xfffc03ffffffffff),
+        UINT64_C(0xfffc07ffffffffff),
+        UINT64_C(0xfffc0fffffffffff),
+        UINT64_C(0xfffc1fffffffffff),
+        UINT64_C(0xfffc3fffffffffff),
+        UINT64_C(0xfffc7fffffffffff),
+        UINT64_C(0xfffcffffffffffff),
+        UINT64_C(0xfffdffffffffffff)
+    },
+    {
+        UINT64_C(0xfff8000000000000),
+        UINT64_C(0xfff8000000000001),
+        UINT64_C(0xfff8000000000003),
+        UINT64_C(0xfff8000000000007),
+        UINT64_C(0xfff800000000000f),
+        UINT64_C(0xfff800000000001f),
+        UINT64_C(0xfff800000000003f),
+        UINT64_C(0xfff800000000007f),
+        UINT64_C(0xfff80000000000ff),
+        UINT64_C(0xfff80000000001ff),
+        UINT64_C(0xfff80000000003ff),
+        UINT64_C(0xfff80000000007ff),
+        UINT64_C(0xfff8000000000fff),
+        UINT64_C(0xfff8000000001fff),
+        UINT64_C(0xfff8000000003fff),
+        UINT64_C(0xfff8000000007fff),
+        UINT64_C(0xfff800000000ffff),
+        UINT64_C(0xfff800000001ffff),
+        UINT64_C(0xfff800000003ffff),
+        UINT64_C(0xfff800000007ffff),
+        UINT64_C(0xfff80000000fffff),
+        UINT64_C(0xfff80000001fffff),
+        UINT64_C(0xfff80000003fffff),
+        UINT64_C(0xfff80000007fffff),
+        UINT64_C(0xfff8000000ffffff),
+        UINT64_C(0xfff8000001ffffff),
+        UINT64_C(0xfff8000003ffffff),
+        UINT64_C(0xfff8000007ffffff),
+        UINT64_C(0xfff800000fffffff),
+        UINT64_C(0xfff800001fffffff),
+        UINT64_C(0xfff800003fffffff),
+        UINT64_C(0xfff800007fffffff),
+        UINT64_C(0xfff80000ffffffff),
+        UINT64_C(0xfff80001ffffffff),
+        UINT64_C(0xfff80003ffffffff),
+        UINT64_C(0xfff80007ffffffff),
+        UINT64_C(0xfff8000fffffffff),
+        UINT64_C(0xfff8001fffffffff),
+        UINT64_C(0xfff8003fffffffff),
+        UINT64_C(0xfff8007fffffffff),
+        UINT64_C(0xfff800ffffffffff),
+        UINT64_C(0xfff801ffffffffff),
+        UINT64_C(0xfff803ffffffffff),
+        UINT64_C(0xfff807ffffffffff),
+        UINT64_C(0xfff80fffffffffff),
+        UINT64_C(0xfff81fffffffffff),
+        UINT64_C(0xfff83fffffffffff),
+        UINT64_C(0xfff87fffffffffff),
+        UINT64_C(0xfff8ffffffffffff),
+        UINT64_C(0xfff9ffffffffffff),
+        UINT64_C(0xfffbffffffffffff)
+    },
+    {
+        UINT64_C(0xfff0000000000000),
+        UINT64_C(0xfff0000000000001),
+        UINT64_C(0xfff0000000000003),
+        UINT64_C(0xfff0000000000007),
+        UINT64_C(0xfff000000000000f),
+        UINT64_C(0xfff000000000001f),
+        UINT64_C(0xfff000000000003f),
+        UINT64_C(0xfff000000000007f),
+        UINT64_C(0xfff00000000000ff),
+        UINT64_C(0xfff00000000001ff),
+        UINT64_C(0xfff00000000003ff),
+        UINT64_C(0xfff00000000007ff),
+        UINT64_C(0xfff0000000000fff),
+        UINT64_C(0xfff0000000001fff),
+        UINT64_C(0xfff0000000003fff),
+        UINT64_C(0xfff0000000007fff),
+        UINT64_C(0xfff000000000ffff),
+        UINT64_C(0xfff000000001ffff),
+        UINT64_C(0xfff000000003ffff),
+        UINT64_C(0xfff000000007ffff),
+        UINT64_C(0xfff00000000fffff),
+        UINT64_C(0xfff00000001fffff),
+        UINT64_C(0xfff00000003fffff),
+        UINT64_C(0xfff00000007fffff),
+        UINT64_C(0xfff0000000ffffff),
+        UINT64_C(0xfff0000001ffffff),
+        UINT64_C(0xfff0000003ffffff),
+        UINT64_C(0xfff0000007ffffff),
+        UINT64_C(0xfff000000fffffff),
+        UINT64_C(0xfff000001fffffff),
+        UINT64_C(0xfff000003fffffff),
+        UINT64_C(0xfff000007fffffff),
+        UINT64_C(0xfff00000ffffffff),
+        UINT64_C(0xfff00001ffffffff),
+        UINT64_C(0xfff00003ffffffff),
+        UINT64_C(0xfff00007ffffffff),
+        UINT64_C(0xfff0000fffffffff),
+        UINT64_C(0xfff0001fffffffff),
+        UINT64_C(0xfff0003fffffffff),
+        UINT64_C(0xfff0007fffffffff),
+        UINT64_C(0xfff000ffffffffff),
+        UINT64_C(0xfff001ffffffffff),
+        UINT64_C(0xfff003ffffffffff),
+        UINT64_C(0xfff007ffffffffff),
+        UINT64_C(0xfff00fffffffffff),
+        UINT64_C(0xfff01fffffffffff),
+        UINT64_C(0xfff03fffffffffff),
+        UINT64_C(0xfff07fffffffffff),
+        UINT64_C(0xfff0ffffffffffff),
+        UINT64_C(0xfff1ffffffffffff),
+        UINT64_C(0xfff3ffffffffffff),
+        UINT64_C(0xfff7ffffffffffff)
+    },
+    {
+        UINT64_C(0xffe0000000000000),
+        UINT64_C(0xffe0000000000001),
+        UINT64_C(0xffe0000000000003),
+        UINT64_C(0xffe0000000000007),
+        UINT64_C(0xffe000000000000f),
+        UINT64_C(0xffe000000000001f),
+        UINT64_C(0xffe000000000003f),
+        UINT64_C(0xffe000000000007f),
+        UINT64_C(0xffe00000000000ff),
+        UINT64_C(0xffe00000000001ff),
+        UINT64_C(0xffe00000000003ff),
+        UINT64_C(0xffe00000000007ff),
+        UINT64_C(0xffe0000000000fff),
+        UINT64_C(0xffe0000000001fff),
+        UINT64_C(0xffe0000000003fff),
+        UINT64_C(0xffe0000000007fff),
+        UINT64_C(0xffe000000000ffff),
+        UINT64_C(0xffe000000001ffff),
+        UINT64_C(0xffe000000003ffff),
+        UINT64_C(0xffe000000007ffff),
+        UINT64_C(0xffe00000000fffff),
+        UINT64_C(0xffe00000001fffff),
+        UINT64_C(0xffe00000003fffff),
+        UINT64_C(0xffe00000007fffff),
+        UINT64_C(0xffe0000000ffffff),
+        UINT64_C(0xffe0000001ffffff),
+        UINT64_C(0xffe0000003ffffff),
+        UINT64_C(0xffe0000007ffffff),
+        UINT64_C(0xffe000000fffffff),
+        UINT64_C(0xffe000001fffffff),
+        UINT64_C(0xffe000003fffffff),
+        UINT64_C(0xffe000007fffffff),
+        UINT64_C(0xffe00000ffffffff),
+        UINT64_C(0xffe00001ffffffff),
+        UINT64_C(0xffe00003ffffffff),
+        UINT64_C(0xffe00007ffffffff),
+        UINT64_C(0xffe0000fffffffff),
+        UINT64_C(0xffe0001fffffffff),
+        UINT64_C(0xffe0003fffffffff),
+        UINT64_C(0xffe0007fffffffff),
+        UINT64_C(0xffe000ffffffffff),
+        UINT64_C(0xffe001ffffffffff),
+        UINT64_C(0xffe003ffffffffff),
+        UINT64_C(0xffe007ffffffffff),
+        UINT64_C(0xffe00fffffffffff),
+        UINT64_C(0xffe01fffffffffff),
+        UINT64_C(0xffe03fffffffffff),
+        UINT64_C(0xffe07fffffffffff),
+        UINT64_C(0xffe0ffffffffffff),
+        UINT64_C(0xffe1ffffffffffff),
+        UINT64_C(0xffe3ffffffffffff),
+        UINT64_C(0xffe7ffffffffffff),
+        UINT64_C(0xffefffffffffffff)
+    },
+    {
+        UINT64_C(0xffc0000000000000),
+        UINT64_C(0xffc0000000000001),
+        UINT64_C(0xffc0000000000003),
+        UINT64_C(0xffc0000000000007),
+        UINT64_C(0xffc000000000000f),
+        UINT64_C(0xffc000000000001f),
+        UINT64_C(0xffc000000000003f),
+        UINT64_C(0xffc000000000007f),
+        UINT64_C(0xffc00000000000ff),
+        UINT64_C(0xffc00000000001ff),
+        UINT64_C(0xffc00000000003ff),
+        UINT64_C(0xffc00000000007ff),
+        UINT64_C(0xffc0000000000fff),
+        UINT64_C(0xffc0000000001fff),
+        UINT64_C(0xffc0000000003fff),
+        UINT64_C(0xffc0000000007fff),
+        UINT64_C(0xffc000000000ffff),
+        UINT64_C(0xffc000000001ffff),
+        UINT64_C(0xffc000000003ffff),
+        UINT64_C(0xffc000000007ffff),
+        UINT64_C(0xffc00000000fffff),
+        UINT64_C(0xffc00000001fffff),
+        UINT64_C(0xffc00000003fffff),
+        UINT64_C(0xffc00000007fffff),
+        UINT64_C(0xffc0000000ffffff),
+        UINT64_C(0xffc0000001ffffff),
+        UINT64_C(0xffc0000003ffffff),
+        UINT64_C(0xffc0000007ffffff),
+        UINT64_C(0xffc000000fffffff),
+        UINT64_C(0xffc000001fffffff),
+        UINT64_C(0xffc000003fffffff),
+        UINT64_C(0xffc000007fffffff),
+        UINT64_C(0xffc00000ffffffff),
+        UINT64_C(0xffc00001ffffffff),
+        UINT64_C(0xffc00003ffffffff),
+        UINT64_C(0xffc00007ffffffff),
+        UINT64_C(0xffc0000fffffffff),
+        UINT64_C(0xffc0001fffffffff),
+        UINT64_C(0xffc0003fffffffff),
+        UINT64_C(0xffc0007fffffffff),
+        UINT64_C(0xffc000ffffffffff),
+        UINT64_C(0xffc001ffffffffff),
+        UINT64_C(0xffc003ffffffffff),
+        UINT64_C(0xffc007ffffffffff),
+        UINT64_C(0xffc00fffffffffff),
+        UINT64_C(0xffc01fffffffffff),
+        UINT64_C(0xffc03fffffffffff),
+        UINT64_C(0xffc07fffffffffff),
+        UINT64_C(0xffc0ffffffffffff),
+        UINT64_C(0xffc1ffffffffffff),
+        UINT64_C(0xffc3ffffffffffff),
+        UINT64_C(0xffc7ffffffffffff),
+        UINT64_C(0xffcfffffffffffff),
+        UINT64_C(0xffdfffffffffffff)
+    },
+    {
+        UINT64_C(0xff80000000000000),
+        UINT64_C(0xff80000000000001),
+        UINT64_C(0xff80000000000003),
+        UINT64_C(0xff80000000000007),
+        UINT64_C(0xff8000000000000f),
+        UINT64_C(0xff8000000000001f),
+        UINT64_C(0xff8000000000003f),
+        UINT64_C(0xff8000000000007f),
+        UINT64_C(0xff800000000000ff),
+        UINT64_C(0xff800000000001ff),
+        UINT64_C(0xff800000000003ff),
+        UINT64_C(0xff800000000007ff),
+        UINT64_C(0xff80000000000fff),
+        UINT64_C(0xff80000000001fff),
+        UINT64_C(0xff80000000003fff),
+        UINT64_C(0xff80000000007fff),
+        UINT64_C(0xff8000000000ffff),
+        UINT64_C(0xff8000000001ffff),
+        UINT64_C(0xff8000000003ffff),
+        UINT64_C(0xff8000000007ffff),
+        UINT64_C(0xff800000000fffff),
+        UINT64_C(0xff800000001fffff),
+        UINT64_C(0xff800000003fffff),
+        UINT64_C(0xff800000007fffff),
+        UINT64_C(0xff80000000ffffff),
+        UINT64_C(0xff80000001ffffff),
+        UINT64_C(0xff80000003ffffff),
+        UINT64_C(0xff80000007ffffff),
+        UINT64_C(0xff8000000fffffff),
+        UINT64_C(0xff8000001fffffff),
+        UINT64_C(0xff8000003fffffff),
+        UINT64_C(0xff8000007fffffff),
+        UINT64_C(0xff800000ffffffff),
+        UINT64_C(0xff800001ffffffff),
+        UINT64_C(0xff800003ffffffff),
+        UINT64_C(0xff800007ffffffff),
+        UINT64_C(0xff80000fffffffff),
+        UINT64_C(0xff80001fffffffff),
+        UINT64_C(0xff80003fffffffff),
+        UINT64_C(0xff80007fffffffff),
+        UINT64_C(0xff8000ffffffffff),
+        UINT64_C(0xff8001ffffffffff),
+        UINT64_C(0xff8003ffffffffff),
+        UINT64_C(0xff8007ffffffffff),
+        UINT64_C(0xff800fffffffffff),
+        UINT64_C(0xff801fffffffffff),
+        UINT64_C(0xff803fffffffffff),
+        UINT64_C(0xff807fffffffffff),
+        UINT64_C(0xff80ffffffffffff),
+        UINT64_C(0xff81ffffffffffff),
+        UINT64_C(0xff83ffffffffffff),
+        UINT64_C(0xff87ffffffffffff),
+        UINT64_C(0xff8fffffffffffff),
+        UINT64_C(0xff9fffffffffffff),
+        UINT64_C(0xffbfffffffffffff)
+    },
+    {
+        UINT64_C(0xff00000000000000),
+        UINT64_C(0xff00000000000001),
+        UINT64_C(0xff00000000000003),
+        UINT64_C(0xff00000000000007),
+        UINT64_C(0xff0000000000000f),
+        UINT64_C(0xff0000000000001f),
+        UINT64_C(0xff0000000000003f),
+        UINT64_C(0xff0000000000007f),
+        UINT64_C(0xff000000000000ff),
+        UINT64_C(0xff000000000001ff),
+        UINT64_C(0xff000000000003ff),
+        UINT64_C(0xff000000000007ff),
+        UINT64_C(0xff00000000000fff),
+        UINT64_C(0xff00000000001fff),
+        UINT64_C(0xff00000000003fff),
+        UINT64_C(0xff00000000007fff),
+        UINT64_C(0xff0000000000ffff),
+        UINT64_C(0xff0000000001ffff),
+        UINT64_C(0xff0000000003ffff),
+        UINT64_C(0xff0000000007ffff),
+        UINT64_C(0xff000000000fffff),
+        UINT64_C(0xff000000001fffff),
+        UINT64_C(0xff000000003fffff),
+        UINT64_C(0xff000000007fffff),
+        UINT64_C(0xff00000000ffffff),
+        UINT64_C(0xff00000001ffffff),
+        UINT64_C(0xff00000003ffffff),
+        UINT64_C(0xff00000007ffffff),
+        UINT64_C(0xff0000000fffffff),
+        UINT64_C(0xff0000001fffffff),
+        UINT64_C(0xff0000003fffffff),
+        UINT64_C(0xff0000007fffffff),
+        UINT64_C(0xff000000ffffffff),
+        UINT64_C(0xff000001ffffffff),
+        UINT64_C(0xff000003ffffffff),
+        UINT64_C(0xff000007ffffffff),
+        UINT64_C(0xff00000fffffffff),
+        UINT64_C(0xff00001fffffffff),
+        UINT64_C(0xff00003fffffffff),
+        UINT64_C(0xff00007fffffffff),
+        UINT64_C(0xff0000ffffffffff),
+        UINT64_C(0xff0001ffffffffff),
+        UINT64_C(0xff0003ffffffffff),
+        UINT64_C(0xff0007ffffffffff),
+        UINT64_C(0xff000fffffffffff),
+        UINT64_C(0xff001fffffffffff),
+        UINT64_C(0xff003fffffffffff),
+        UINT64_C(0xff007fffffffffff),
+        UINT64_C(0xff00ffffffffffff),
+        UINT64_C(0xff01ffffffffffff),
+        UINT64_C(0xff03ffffffffffff),
+        UINT64_C(0xff07ffffffffffff),
+        UINT64_C(0xff0fffffffffffff),
+        UINT64_C(0xff1fffffffffffff),
+        UINT64_C(0xff3fffffffffffff),
+        UINT64_C(0xff7fffffffffffff)
+    },
+    {
+        UINT64_C(0xfe00000000000000),
+        UINT64_C(0xfe00000000000001),
+        UINT64_C(0xfe00000000000003),
+        UINT64_C(0xfe00000000000007),
+        UINT64_C(0xfe0000000000000f),
+        UINT64_C(0xfe0000000000001f),
+        UINT64_C(0xfe0000000000003f),
+        UINT64_C(0xfe0000000000007f),
+        UINT64_C(0xfe000000000000ff),
+        UINT64_C(0xfe000000000001ff),
+        UINT64_C(0xfe000000000003ff),
+        UINT64_C(0xfe000000000007ff),
+        UINT64_C(0xfe00000000000fff),
+        UINT64_C(0xfe00000000001fff),
+        UINT64_C(0xfe00000000003fff),
+        UINT64_C(0xfe00000000007fff),
+        UINT64_C(0xfe0000000000ffff),
+        UINT64_C(0xfe0000000001ffff),
+        UINT64_C(0xfe0000000003ffff),
+        UINT64_C(0xfe0000000007ffff),
+        UINT64_C(0xfe000000000fffff),
+        UINT64_C(0xfe000000001fffff),
+        UINT64_C(0xfe000000003fffff),
+        UINT64_C(0xfe000000007fffff),
+        UINT64_C(0xfe00000000ffffff),
+        UINT64_C(0xfe00000001ffffff),
+        UINT64_C(0xfe00000003ffffff),
+        UINT64_C(0xfe00000007ffffff),
+        UINT64_C(0xfe0000000fffffff),
+        UINT64_C(0xfe0000001fffffff),
+        UINT64_C(0xfe0000003fffffff),
+        UINT64_C(0xfe0000007fffffff),
+        UINT64_C(0xfe000000ffffffff),
+        UINT64_C(0xfe000001ffffffff),
+        UINT64_C(0xfe000003ffffffff),
+        UINT64_C(0xfe000007ffffffff),
+        UINT64_C(0xfe00000fffffffff),
+        UINT64_C(0xfe00001fffffffff),
+        UINT64_C(0xfe00003fffffffff),
+        UINT64_C(0xfe00007fffffffff),
+        UINT64_C(0xfe0000ffffffffff),
+        UINT64_C(0xfe0001ffffffffff),
+        UINT64_C(0xfe0003ffffffffff),
+        UINT64_C(0xfe0007ffffffffff),
+        UINT64_C(0xfe000fffffffffff),
+        UINT64_C(0xfe001fffffffffff),
+        UINT64_C(0xfe003fffffffffff),
+        UINT64_C(0xfe007fffffffffff),
+        UINT64_C(0xfe00ffffffffffff),
+        UINT64_C(0xfe01ffffffffffff),
+        UINT64_C(0xfe03ffffffffffff),
+        UINT64_C(0xfe07ffffffffffff),
+        UINT64_C(0xfe0fffffffffffff),
+        UINT64_C(0xfe1fffffffffffff),
+        UINT64_C(0xfe3fffffffffffff),
+        UINT64_C(0xfe7fffffffffffff),
+        UINT64_C(0xfeffffffffffffff)
+    },
+    {
+        UINT64_C(0xfc00000000000000),
+        UINT64_C(0xfc00000000000001),
+        UINT64_C(0xfc00000000000003),
+        UINT64_C(0xfc00000000000007),
+        UINT64_C(0xfc0000000000000f),
+        UINT64_C(0xfc0000000000001f),
+        UINT64_C(0xfc0000000000003f),
+        UINT64_C(0xfc0000000000007f),
+        UINT64_C(0xfc000000000000ff),
+        UINT64_C(0xfc000000000001ff),
+        UINT64_C(0xfc000000000003ff),
+        UINT64_C(0xfc000000000007ff),
+        UINT64_C(0xfc00000000000fff),
+        UINT64_C(0xfc00000000001fff),
+        UINT64_C(0xfc00000000003fff),
+        UINT64_C(0xfc00000000007fff),
+        UINT64_C(0xfc0000000000ffff),
+        UINT64_C(0xfc0000000001ffff),
+        UINT64_C(0xfc0000000003ffff),
+        UINT64_C(0xfc0000000007ffff),
+        UINT64_C(0xfc000000000fffff),
+        UINT64_C(0xfc000000001fffff),
+        UINT64_C(0xfc000000003fffff),
+        UINT64_C(0xfc000000007fffff),
+        UINT64_C(0xfc00000000ffffff),
+        UINT64_C(0xfc00000001ffffff),
+        UINT64_C(0xfc00000003ffffff),
+        UINT64_C(0xfc00000007ffffff),
+        UINT64_C(0xfc0000000fffffff),
+        UINT64_C(0xfc0000001fffffff),
+        UINT64_C(0xfc0000003fffffff),
+        UINT64_C(0xfc0000007fffffff),
+        UINT64_C(0xfc000000ffffffff),
+        UINT64_C(0xfc000001ffffffff),
+        UINT64_C(0xfc000003ffffffff),
+        UINT64_C(0xfc000007ffffffff),
+        UINT64_C(0xfc00000fffffffff),
+        UINT64_C(0xfc00001fffffffff),
+        UINT64_C(0xfc00003fffffffff),
+        UINT64_C(0xfc00007fffffffff),
+        UINT64_C(0xfc0000ffffffffff),
+        UINT64_C(0xfc0001ffffffffff),
+        UINT64_C(0xfc0003ffffffffff),
+        UINT64_C(0xfc0007ffffffffff),
+        UINT64_C(0xfc000fffffffffff),
+        UINT64_C(0xfc001fffffffffff),
+        UINT64_C(0xfc003fffffffffff),
+        UINT64_C(0xfc007fffffffffff),
+        UINT64_C(0xfc00ffffffffffff),
+        UINT64_C(0xfc01ffffffffffff),
+        UINT64_C(0xfc03ffffffffffff),
+        UINT64_C(0xfc07ffffffffffff),
+        UINT64_C(0xfc0fffffffffffff),
+        UINT64_C(0xfc1fffffffffffff),
+        UINT64_C(0xfc3fffffffffffff),
+        UINT64_C(0xfc7fffffffffffff),
+        UINT64_C(0xfcffffffffffffff),
+        UINT64_C(0xfdffffffffffffff)
+    },
+    {
+        UINT64_C(0xf800000000000000),
+        UINT64_C(0xf800000000000001),
+        UINT64_C(0xf800000000000003),
+        UINT64_C(0xf800000000000007),
+        UINT64_C(0xf80000000000000f),
+        UINT64_C(0xf80000000000001f),
+        UINT64_C(0xf80000000000003f),
+        UINT64_C(0xf80000000000007f),
+        UINT64_C(0xf8000000000000ff),
+        UINT64_C(0xf8000000000001ff),
+        UINT64_C(0xf8000000000003ff),
+        UINT64_C(0xf8000000000007ff),
+        UINT64_C(0xf800000000000fff),
+        UINT64_C(0xf800000000001fff),
+        UINT64_C(0xf800000000003fff),
+        UINT64_C(0xf800000000007fff),
+        UINT64_C(0xf80000000000ffff),
+        UINT64_C(0xf80000000001ffff),
+        UINT64_C(0xf80000000003ffff),
+        UINT64_C(0xf80000000007ffff),
+        UINT64_C(0xf8000000000fffff),
+        UINT64_C(0xf8000000001fffff),
+        UINT64_C(0xf8000000003fffff),
+        UINT64_C(0xf8000000007fffff),
+        UINT64_C(0xf800000000ffffff),
+        UINT64_C(0xf800000001ffffff),
+        UINT64_C(0xf800000003ffffff),
+        UINT64_C(0xf800000007ffffff),
+        UINT64_C(0xf80000000fffffff),
+        UINT64_C(0xf80000001fffffff),
+        UINT64_C(0xf80000003fffffff),
+        UINT64_C(0xf80000007fffffff),
+        UINT64_C(0xf8000000ffffffff),
+        UINT64_C(0xf8000001ffffffff),
+        UINT64_C(0xf8000003ffffffff),
+        UINT64_C(0xf8000007ffffffff),
+        UINT64_C(0xf800000fffffffff),
+        UINT64_C(0xf800001fffffffff),
+        UINT64_C(0xf800003fffffffff),
+        UINT64_C(0xf800007fffffffff),
+        UINT64_C(0xf80000ffffffffff),
+        UINT64_C(0xf80001ffffffffff),
+        UINT64_C(0xf80003ffffffffff),
+        UINT64_C(0xf80007ffffffffff),
+        UINT64_C(0xf8000fffffffffff),
+        UINT64_C(0xf8001fffffffffff),
+        UINT64_C(0xf8003fffffffffff),
+        UINT64_C(0xf8007fffffffffff),
+        UINT64_C(0xf800ffffffffffff),
+        UINT64_C(0xf801ffffffffffff),
+        UINT64_C(0xf803ffffffffffff),
+        UINT64_C(0xf807ffffffffffff),
+        UINT64_C(0xf80fffffffffffff),
+        UINT64_C(0xf81fffffffffffff),
+        UINT64_C(0xf83fffffffffffff),
+        UINT64_C(0xf87fffffffffffff),
+        UINT64_C(0xf8ffffffffffffff),
+        UINT64_C(0xf9ffffffffffffff),
+        UINT64_C(0xfbffffffffffffff)
+    },
+    {
+        UINT64_C(0xf000000000000000),
+        UINT64_C(0xf000000000000001),
+        UINT64_C(0xf000000000000003),
+        UINT64_C(0xf000000000000007),
+        UINT64_C(0xf00000000000000f),
+        UINT64_C(0xf00000000000001f),
+        UINT64_C(0xf00000000000003f),
+        UINT64_C(0xf00000000000007f),
+        UINT64_C(0xf0000000000000ff),
+        UINT64_C(0xf0000000000001ff),
+        UINT64_C(0xf0000000000003ff),
+        UINT64_C(0xf0000000000007ff),
+        UINT64_C(0xf000000000000fff),
+        UINT64_C(0xf000000000001fff),
+        UINT64_C(0xf000000000003fff),
+        UINT64_C(0xf000000000007fff),
+        UINT64_C(0xf00000000000ffff),
+        UINT64_C(0xf00000000001ffff),
+        UINT64_C(0xf00000000003ffff),
+        UINT64_C(0xf00000000007ffff),
+        UINT64_C(0xf0000000000fffff),
+        UINT64_C(0xf0000000001fffff),
+        UINT64_C(0xf0000000003fffff),
+        UINT64_C(0xf0000000007fffff),
+        UINT64_C(0xf000000000ffffff),
+        UINT64_C(0xf000000001ffffff),
+        UINT64_C(0xf000000003ffffff),
+        UINT64_C(0xf000000007ffffff),
+        UINT64_C(0xf00000000fffffff),
+        UINT64_C(0xf00000001fffffff),
+        UINT64_C(0xf00000003fffffff),
+        UINT64_C(0xf00000007fffffff),
+        UINT64_C(0xf0000000ffffffff),
+        UINT64_C(0xf0000001ffffffff),
+        UINT64_C(0xf0000003ffffffff),
+        UINT64_C(0xf0000007ffffffff),
+        UINT64_C(0xf000000fffffffff),
+        UINT64_C(0xf000001fffffffff),
+        UINT64_C(0xf000003fffffffff),
+        UINT64_C(0xf000007fffffffff),
+        UINT64_C(0xf00000ffffffffff),
+        UINT64_C(0xf00001ffffffffff),
+        UINT64_C(0xf00003ffffffffff),
+        UINT64_C(0xf00007ffffffffff),
+        UINT64_C(0xf0000fffffffffff),
+        UINT64_C(0xf0001fffffffffff),
+        UINT64_C(0xf0003fffffffffff),
+        UINT64_C(0xf0007fffffffffff),
+        UINT64_C(0xf000ffffffffffff),
+        UINT64_C(0xf001ffffffffffff),
+        UINT64_C(0xf003ffffffffffff),
+        UINT64_C(0xf007ffffffffffff),
+        UINT64_C(0xf00fffffffffffff),
+        UINT64_C(0xf01fffffffffffff),
+        UINT64_C(0xf03fffffffffffff),
+        UINT64_C(0xf07fffffffffffff),
+        UINT64_C(0xf0ffffffffffffff),
+        UINT64_C(0xf1ffffffffffffff),
+        UINT64_C(0xf3ffffffffffffff),
+        UINT64_C(0xf7ffffffffffffff)
+    },
+    {
+        UINT64_C(0xe000000000000000),
+        UINT64_C(0xe000000000000001),
+        UINT64_C(0xe000000000000003),
+        UINT64_C(0xe000000000000007),
+        UINT64_C(0xe00000000000000f),
+        UINT64_C(0xe00000000000001f),
+        UINT64_C(0xe00000000000003f),
+        UINT64_C(0xe00000000000007f),
+        UINT64_C(0xe0000000000000ff),
+        UINT64_C(0xe0000000000001ff),
+        UINT64_C(0xe0000000000003ff),
+        UINT64_C(0xe0000000000007ff),
+        UINT64_C(0xe000000000000fff),
+        UINT64_C(0xe000000000001fff),
+        UINT64_C(0xe000000000003fff),
+        UINT64_C(0xe000000000007fff),
+        UINT64_C(0xe00000000000ffff),
+        UINT64_C(0xe00000000001ffff),
+        UINT64_C(0xe00000000003ffff),
+        UINT64_C(0xe00000000007ffff),
+        UINT64_C(0xe0000000000fffff),
+        UINT64_C(0xe0000000001fffff),
+        UINT64_C(0xe0000000003fffff),
+        UINT64_C(0xe0000000007fffff),
+        UINT64_C(0xe000000000ffffff),
+        UINT64_C(0xe000000001ffffff),
+        UINT64_C(0xe000000003ffffff),
+        UINT64_C(0xe000000007ffffff),
+        UINT64_C(0xe00000000fffffff),
+        UINT64_C(0xe00000001fffffff),
+        UINT64_C(0xe00000003fffffff),
+        UINT64_C(0xe00000007fffffff),
+        UINT64_C(0xe0000000ffffffff),
+        UINT64_C(0xe0000001ffffffff),
+        UINT64_C(0xe0000003ffffffff),
+        UINT64_C(0xe0000007ffffffff),
+        UINT64_C(0xe000000fffffffff),
+        UINT64_C(0xe000001fffffffff),
+        UINT64_C(0xe000003fffffffff),
+        UINT64_C(0xe000007fffffffff),
+        UINT64_C(0xe00000ffffffffff),
+        UINT64_C(0xe00001ffffffffff),
+        UINT64_C(0xe00003ffffffffff),
+        UINT64_C(0xe00007ffffffffff),
+        UINT64_C(0xe0000fffffffffff),
+        UINT64_C(0xe0001fffffffffff),
+        UINT64_C(0xe0003fffffffffff),
+        UINT64_C(0xe0007fffffffffff),
+        UINT64_C(0xe000ffffffffffff),
+        UINT64_C(0xe001ffffffffffff),
+        UINT64_C(0xe003ffffffffffff),
+        UINT64_C(0xe007ffffffffffff),
+        UINT64_C(0xe00fffffffffffff),
+        UINT64_C(0xe01fffffffffffff),
+        UINT64_C(0xe03fffffffffffff),
+        UINT64_C(0xe07fffffffffffff),
+        UINT64_C(0xe0ffffffffffffff),
+        UINT64_C(0xe1ffffffffffffff),
+        UINT64_C(0xe3ffffffffffffff),
+        UINT64_C(0xe7ffffffffffffff),
+        UINT64_C(0xefffffffffffffff)
+    },
+    {
+        UINT64_C(0xc000000000000000),
+        UINT64_C(0xc000000000000001),
+        UINT64_C(0xc000000000000003),
+        UINT64_C(0xc000000000000007),
+        UINT64_C(0xc00000000000000f),
+        UINT64_C(0xc00000000000001f),
+        UINT64_C(0xc00000000000003f),
+        UINT64_C(0xc00000000000007f),
+        UINT64_C(0xc0000000000000ff),
+        UINT64_C(0xc0000000000001ff),
+        UINT64_C(0xc0000000000003ff),
+        UINT64_C(0xc0000000000007ff),
+        UINT64_C(0xc000000000000fff),
+        UINT64_C(0xc000000000001fff),
+        UINT64_C(0xc000000000003fff),
+        UINT64_C(0xc000000000007fff),
+        UINT64_C(0xc00000000000ffff),
+        UINT64_C(0xc00000000001ffff),
+        UINT64_C(0xc00000000003ffff),
+        UINT64_C(0xc00000000007ffff),
+        UINT64_C(0xc0000000000fffff),
+        UINT64_C(0xc0000000001fffff),
+        UINT64_C(0xc0000000003fffff),
+        UINT64_C(0xc0000000007fffff),
+        UINT64_C(0xc000000000ffffff),
+        UINT64_C(0xc000000001ffffff),
+        UINT64_C(0xc000000003ffffff),
+        UINT64_C(0xc000000007ffffff),
+        UINT64_C(0xc00000000fffffff),
+        UINT64_C(0xc00000001fffffff),
+        UINT64_C(0xc00000003fffffff),
+        UINT64_C(0xc00000007fffffff),
+        UINT64_C(0xc0000000ffffffff),
+        UINT64_C(0xc0000001ffffffff),
+        UINT64_C(0xc0000003ffffffff),
+        UINT64_C(0xc0000007ffffffff),
+        UINT64_C(0xc000000fffffffff),
+        UINT64_C(0xc000001fffffffff),
+        UINT64_C(0xc000003fffffffff),
+        UINT64_C(0xc000007fffffffff),
+        UINT64_C(0xc00000ffffffffff),
+        UINT64_C(0xc00001ffffffffff),
+        UINT64_C(0xc00003ffffffffff),
+        UINT64_C(0xc00007ffffffffff),
+        UINT64_C(0xc0000fffffffffff),
+        UINT64_C(0xc0001fffffffffff),
+        UINT64_C(0xc0003fffffffffff),
+        UINT64_C(0xc0007fffffffffff),
+        UINT64_C(0xc000ffffffffffff),
+        UINT64_C(0xc001ffffffffffff),
+        UINT64_C(0xc003ffffffffffff),
+        UINT64_C(0xc007ffffffffffff),
+        UINT64_C(0xc00fffffffffffff),
+        UINT64_C(0xc01fffffffffffff),
+        UINT64_C(0xc03fffffffffffff),
+        UINT64_C(0xc07fffffffffffff),
+        UINT64_C(0xc0ffffffffffffff),
+        UINT64_C(0xc1ffffffffffffff),
+        UINT64_C(0xc3ffffffffffffff),
+        UINT64_C(0xc7ffffffffffffff),
+        UINT64_C(0xcfffffffffffffff),
+        UINT64_C(0xdfffffffffffffff)
+    },
+    {
+        UINT64_C(0x8000000000000000),
+        UINT64_C(0x8000000000000001),
+        UINT64_C(0x8000000000000003),
+        UINT64_C(0x8000000000000007),
+        UINT64_C(0x800000000000000f),
+        UINT64_C(0x800000000000001f),
+        UINT64_C(0x800000000000003f),
+        UINT64_C(0x800000000000007f),
+        UINT64_C(0x80000000000000ff),
+        UINT64_C(0x80000000000001ff),
+        UINT64_C(0x80000000000003ff),
+        UINT64_C(0x80000000000007ff),
+        UINT64_C(0x8000000000000fff),
+        UINT64_C(0x8000000000001fff),
+        UINT64_C(0x8000000000003fff),
+        UINT64_C(0x8000000000007fff),
+        UINT64_C(0x800000000000ffff),
+        UINT64_C(0x800000000001ffff),
+        UINT64_C(0x800000000003ffff),
+        UINT64_C(0x800000000007ffff),
+        UINT64_C(0x80000000000fffff),
+        UINT64_C(0x80000000001fffff),
+        UINT64_C(0x80000000003fffff),
+        UINT64_C(0x80000000007fffff),
+        UINT64_C(0x8000000000ffffff),
+        UINT64_C(0x8000000001ffffff),
+        UINT64_C(0x8000000003ffffff),
+        UINT64_C(0x8000000007ffffff),
+        UINT64_C(0x800000000fffffff),
+        UINT64_C(0x800000001fffffff),
+        UINT64_C(0x800000003fffffff),
+        UINT64_C(0x800000007fffffff),
+        UINT64_C(0x80000000ffffffff),
+        UINT64_C(0x80000001ffffffff),
+        UINT64_C(0x80000003ffffffff),
+        UINT64_C(0x80000007ffffffff),
+        UINT64_C(0x8000000fffffffff),
+        UINT64_C(0x8000001fffffffff),
+        UINT64_C(0x8000003fffffffff),
+        UINT64_C(0x8000007fffffffff),
+        UINT64_C(0x800000ffffffffff),
+        UINT64_C(0x800001ffffffffff),
+        UINT64_C(0x800003ffffffffff),
+        UINT64_C(0x800007ffffffffff),
+        UINT64_C(0x80000fffffffffff),
+        UINT64_C(0x80001fffffffffff),
+        UINT64_C(0x80003fffffffffff),
+        UINT64_C(0x80007fffffffffff),
+        UINT64_C(0x8000ffffffffffff),
+        UINT64_C(0x8001ffffffffffff),
+        UINT64_C(0x8003ffffffffffff),
+        UINT64_C(0x8007ffffffffffff),
+        UINT64_C(0x800fffffffffffff),
+        UINT64_C(0x801fffffffffffff),
+        UINT64_C(0x803fffffffffffff),
+        UINT64_C(0x807fffffffffffff),
+        UINT64_C(0x80ffffffffffffff),
+        UINT64_C(0x81ffffffffffffff),
+        UINT64_C(0x83ffffffffffffff),
+        UINT64_C(0x87ffffffffffffff),
+        UINT64_C(0x8fffffffffffffff),
+        UINT64_C(0x9fffffffffffffff),
+        UINT64_C(0xbfffffffffffffff)
+    },
+    {
+        UINT64_C(0x0),
+        UINT64_C(0x1),
+        UINT64_C(0x3),
+        UINT64_C(0x7),
+        UINT64_C(0xf),
+        UINT64_C(0x1f),
+        UINT64_C(0x3f),
+        UINT64_C(0x7f),
+        UINT64_C(0xff),
+        UINT64_C(0x1ff),
+        UINT64_C(0x3ff),
+        UINT64_C(0x7ff),
+        UINT64_C(0xfff),
+        UINT64_C(0x1fff),
+        UINT64_C(0x3fff),
+        UINT64_C(0x7fff),
+        UINT64_C(0xffff),
+        UINT64_C(0x1ffff),
+        UINT64_C(0x3ffff),
+        UINT64_C(0x7ffff),
+        UINT64_C(0xfffff),
+        UINT64_C(0x1fffff),
+        UINT64_C(0x3fffff),
+        UINT64_C(0x7fffff),
+        UINT64_C(0xffffff),
+        UINT64_C(0x1ffffff),
+        UINT64_C(0x3ffffff),
+        UINT64_C(0x7ffffff),
+        UINT64_C(0xfffffff),
+        UINT64_C(0x1fffffff),
+        UINT64_C(0x3fffffff),
+        UINT64_C(0x7fffffff),
+        UINT64_C(0xffffffff),
+        UINT64_C(0x1ffffffff),
+        UINT64_C(0x3ffffffff),
+        UINT64_C(0x7ffffffff),
+        UINT64_C(0xfffffffff),
+        UINT64_C(0x1fffffffff),
+        UINT64_C(0x3fffffffff),
+        UINT64_C(0x7fffffffff),
+        UINT64_C(0xffffffffff),
+        UINT64_C(0x1ffffffffff),
+        UINT64_C(0x3ffffffffff),
+        UINT64_C(0x7ffffffffff),
+        UINT64_C(0xfffffffffff),
+        UINT64_C(0x1fffffffffff),
+        UINT64_C(0x3fffffffffff),
+        UINT64_C(0x7fffffffffff),
+        UINT64_C(0xffffffffffff),
+        UINT64_C(0x1ffffffffffff),
+        UINT64_C(0x3ffffffffffff),
+        UINT64_C(0x7ffffffffffff),
+        UINT64_C(0xfffffffffffff),
+        UINT64_C(0x1fffffffffffff),
+        UINT64_C(0x3fffffffffffff),
+        UINT64_C(0x7fffffffffffff),
+        UINT64_C(0xffffffffffffff),
+        UINT64_C(0x1ffffffffffffff),
+        UINT64_C(0x3ffffffffffffff),
+        UINT64_C(0x7ffffffffffffff),
+        UINT64_C(0xfffffffffffffff),
+        UINT64_C(0x1fffffffffffffff),
+        UINT64_C(0x3fffffffffffffff),
+        UINT64_C(0x7fffffffffffffff)
+    }
+};
+
+} // namespace sc_dt
diff --git a/src/systemc/dt/int/sc_length_param.cc b/src/systemc/dt/int/sc_length_param.cc
new file mode 100644
index 0000000..920da13
--- /dev/null
+++ b/src/systemc/dt/int/sc_length_param.cc
@@ -0,0 +1,91 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_length_param.cpp -
+
+  Original Author: Martin Janssen, Synopsys, Inc., 2002-03-19
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: sc_length_param.cpp,v $
+// Revision 1.2  2011/02/18 20:19:15  acg
+//  Andy Goodrich: updating Copyright notice.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:49:32  acg
+// Added $Log command so that CVS check in comments are reproduced in the
+// source.
+//
+
+#include <sstream>
+
+#include "systemc/ext/dt/int/sc_length_param.hh"
+
+namespace sc_dt
+{
+
+// explicit template instantiations
+template class sc_global<sc_length_param>;
+template class sc_context<sc_length_param>;
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_length_param
+//
+//  Length parameter type.
+// ----------------------------------------------------------------------------
+
+const std::string
+sc_length_param::to_string() const
+{
+    std::stringstream ss;
+    print(ss);
+    return ss.str();
+}
+
+void
+sc_length_param::print(::std::ostream &os) const
+{
+    os << "(" << m_len << ")";
+}
+
+void
+sc_length_param::dump(::std::ostream &os) const
+{
+    os << "sc_length_param" << ::std::endl;
+    os << "(" << ::std::endl;
+    os << "len = " << m_len << ::std::endl;
+    os << ")" << ::std::endl;
+}
+
+} // namespace sc_dt
diff --git a/src/systemc/dt/int/sc_nbcommon.inc b/src/systemc/dt/int/sc_nbcommon.inc
new file mode 100644
index 0000000..90507ff
--- /dev/null
+++ b/src/systemc/dt/int/sc_nbcommon.inc
@@ -0,0 +1,2617 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_nbcommon.cpp -- Functions common to both sc_signed and sc_unsigned.
+                     This file is included in sc_signed.cpp and
+                     sc_unsigned.cpp after the macros are defined accordingly.
+                     For example, sc_signed.cpp will first define CLASS_TYPE
+                     as sc_signed before including this file. This file like
+                     sc_nbfriends.cpp and sc_nbexterns.cpp is created in order
+                     to ensure only one version of each function, regardless
+                     of the class that they interface to.
+
+  Original Author: Ali Dasdan, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// ----------------------------------------------------------------------------
+//  SECTION : Public members
+// ----------------------------------------------------------------------------
+
+// Create a CLASS_TYPE number with nb bits.
+CLASS_TYPE::CLASS_TYPE(int nb) :
+    sc_value_base(), sgn(), nbits(), ndigits(), digit()
+{
+    sgn = default_sign();
+    if (nb > 0) {
+	nbits = num_bits(nb);
+    } else {
+        invalid_init("int nb", nb);
+        sc_core::sc_abort(); // can't recover from here
+    }
+    ndigits = DIV_CEIL(nbits);
+#ifdef SC_MAX_NBITS
+    test_bound(nb);
+#else
+    digit = new sc_digit[ndigits];
+#endif
+    makezero();
+}
+
+
+// Create a copy of v with sgn s. v is of the same type.
+CLASS_TYPE::CLASS_TYPE(const CLASS_TYPE &v) :
+    sc_value_base(v), sgn(v.sgn), nbits(v.nbits), ndigits(v.ndigits), digit()
+{
+#ifndef SC_MAX_NBITS
+  digit = new sc_digit[ndigits];
+#endif
+
+  vec_copy(ndigits, digit, v.digit);
+}
+
+
+// Create a copy of v where v is of the different type.
+CLASS_TYPE::CLASS_TYPE(const OTHER_CLASS_TYPE &v) :
+    sc_value_base(v), sgn(v.sgn), nbits(num_bits(v.nbits)), ndigits(), digit()
+{
+#if (IF_SC_SIGNED == 1)
+  ndigits = v.ndigits;
+#else
+  ndigits = DIV_CEIL(nbits);
+#endif
+
+#ifndef SC_MAX_NBITS
+  digit = new sc_digit[ndigits];
+#endif
+
+  copy_digits(v.nbits, v.ndigits, v.digit);
+}
+
+// Create a copy of v where v is an sign-less instance.
+CLASS_TYPE::CLASS_TYPE(const sc_bv_base &v) :
+    sc_value_base(), sgn(), nbits(), ndigits(), digit()
+{
+    int nb = v.length();
+    sgn = default_sign();
+    if (nb > 0) {
+        nbits = num_bits(nb);
+    } else {
+        invalid_init("sc_bv_base", nb);
+        sc_core::sc_abort(); // can't recover from here
+    }
+    ndigits = DIV_CEIL(nbits);
+#   ifdef SC_MAX_NBITS
+        test_bound(nb);
+#    else
+        digit = new sc_digit[ndigits];
+#    endif
+    makezero();
+    *this = v;
+}
+
+CLASS_TYPE::CLASS_TYPE(const sc_lv_base &v) :
+    sc_value_base(), sgn(), nbits(), ndigits(), digit()
+{
+    int nb = v.length();
+    sgn = default_sign();
+    if (nb > 0) {
+        nbits = num_bits(nb);
+    } else {
+        invalid_init("sc_lv_base", nb);
+        sc_core::sc_abort(); // can't recover from here
+    }
+    ndigits = DIV_CEIL(nbits);
+#   ifdef SC_MAX_NBITS
+        test_bound(nb);
+#    else
+        digit = new sc_digit[ndigits];
+#    endif
+    makezero();
+    *this = v;
+}
+
+CLASS_TYPE::CLASS_TYPE(const sc_int_subref_r &v) :
+    sc_value_base(v), sgn(), nbits(), ndigits(), digit()
+{
+    int nb = v.length();
+    sgn = default_sign();
+    if (nb > 0) {
+        nbits = num_bits(nb);
+    } else {
+        invalid_init("sc_int_subref", nb);
+        sc_core::sc_abort(); // can't recover from here
+    }
+    ndigits = DIV_CEIL(nbits);
+#   ifdef SC_MAX_NBITS
+        test_bound(nb);
+#    else
+        digit = new sc_digit[ndigits];
+#    endif
+    makezero();
+    *this = v.to_uint64();
+}
+
+CLASS_TYPE::CLASS_TYPE(const sc_uint_subref_r &v) :
+    sc_value_base(v), sgn(), nbits(), ndigits(), digit()
+{
+    int nb = v.length();
+    sgn = default_sign();
+    if (nb > 0) {
+        nbits = num_bits(nb);
+    } else {
+        invalid_init("sc_uint_subref", nb);
+        sc_core::sc_abort(); // can't recover from here
+    }
+    ndigits = DIV_CEIL(nbits);
+#   ifdef SC_MAX_NBITS
+        test_bound(nb);
+#    else
+        digit = new sc_digit[ndigits];
+#    endif
+    makezero();
+    *this = v.to_uint64();
+}
+
+CLASS_TYPE::CLASS_TYPE(const sc_signed_subref_r &v) :
+    sc_value_base(v), sgn(), nbits(), ndigits(), digit()
+{
+    int nb = v.length();
+    sgn = default_sign();
+    if (nb > 0) {
+        nbits = num_bits(nb);
+    } else {
+        invalid_init("sc_signed_subref", nb);
+        sc_core::sc_abort(); // can't recover from here
+    }
+    ndigits = DIV_CEIL(nbits);
+#   ifdef SC_MAX_NBITS
+        test_bound(nb);
+#    else
+        digit = new sc_digit[ndigits];
+#    endif
+    makezero();
+    *this = sc_unsigned(v.m_obj_p, v.m_left, v.m_right);
+}
+
+CLASS_TYPE::CLASS_TYPE(const sc_unsigned_subref_r &v) :
+    sc_value_base(v), sgn(), nbits(), ndigits(), digit()
+{
+    int nb = v.length();
+    sgn = default_sign();
+    if (nb > 0) {
+        nbits = num_bits(nb);
+    } else {
+        invalid_init("sc_unsigned_subref", nb);
+        sc_core::sc_abort(); // can't recover from here
+    }
+    ndigits = DIV_CEIL(nbits);
+#   ifdef SC_MAX_NBITS
+        test_bound(nb);
+#    else
+        digit = new sc_digit[ndigits];
+#    endif
+    makezero();
+    *this = sc_unsigned(v.m_obj_p, v.m_left, v.m_right);
+}
+
+// ----------------------------------------------------------------------------
+//  SECTION: Public members - Concatenation support.
+// ----------------------------------------------------------------------------
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Public members - Assignment operators.
+// ----------------------------------------------------------------------------
+
+// Assignment from v of the same type.
+const CLASS_TYPE &
+CLASS_TYPE::operator = (const CLASS_TYPE &v)
+{
+    if (this != &v) {
+        sgn = v.sgn;
+
+        if (sgn == SC_ZERO)
+            vec_zero(ndigits, digit);
+        else
+            copy_digits(v.nbits, v.ndigits, v.digit);
+    }
+    return *this;
+}
+
+
+// Assignment from v of the different type.
+const CLASS_TYPE &
+CLASS_TYPE::operator = (const OTHER_CLASS_TYPE &v)
+{
+    sgn = v.sgn;
+
+    if (sgn == SC_ZERO)
+        vec_zero(ndigits, digit);
+    else
+        copy_digits(v.nbits, v.ndigits, v.digit);
+
+    return *this;
+}
+
+
+// Assignment from an sc_unsigned_subref_r
+const CLASS_TYPE &
+CLASS_TYPE::operator = (const sc_unsigned_subref_r &v)
+{
+    return operator=(sc_unsigned(v));
+}
+
+
+// Assignment from an sc_signed_subref_r
+const CLASS_TYPE &
+CLASS_TYPE::operator = (const sc_signed_subref_r &v)
+{
+    return operator = (sc_unsigned(v));
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Input and output operators
+// ----------------------------------------------------------------------------
+
+void
+CLASS_TYPE::scan(::std::istream &is)
+{
+    std::string s;
+    is >> s;
+    *this = s.c_str();
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: PLUS operators: +, +=, ++
+// ----------------------------------------------------------------------------
+
+// Cases to consider when computing u + v:
+// 1. 0 + v = v
+// 2. u + 0 = u
+// 3. if sgn(u) == sgn(v)
+//    3.1 u + v = +(u + v) = sgn(u) * (u + v)
+//    3.2 (-u) + (-v) = -(u + v) = sgn(u) * (u + v)
+// 4. if sgn(u) != sgn(v)
+//    4.1 u + (-v) = u - v = sgn(u) * (u - v)
+//    4.2 (-u) + v = -(u - v) ==> sgn(u) * (u - v)
+//
+// Specialization of above cases for computing ++u or u++:
+// 1. 0 + 1 = 1
+// 3. u + 1 = u + 1 = sgn(u) * (u + 1)
+// 4. (-u) + 1 = -(u - 1) = sgn(u) * (u - 1)
+
+const CLASS_TYPE &
+CLASS_TYPE::operator += (const CLASS_TYPE &v)
+{
+    // u = *this
+
+    if (sgn == SC_ZERO) // case 1
+        return (*this = v);
+
+    if (v.sgn == SC_ZERO) // case 2
+        return *this;
+
+    // cases 3 and 4
+    add_on_help(sgn, nbits, ndigits, digit,
+                v.sgn, v.nbits, v.ndigits, v.digit);
+
+    convert_SM_to_2C_to_SM();
+
+    return *this;
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator += (const OTHER_CLASS_TYPE &v)
+{
+    // u = *this
+
+    if (sgn == SC_ZERO) // case 1
+        return (*this = v);
+
+    if (v.sgn == SC_ZERO) // case 2
+        return *this;
+
+    // cases 3 and 4
+    add_on_help(sgn, nbits, ndigits, digit,
+                v.sgn, v.nbits, v.ndigits, v.digit);
+
+    convert_SM_to_2C_to_SM();
+
+    return *this;
+}
+
+
+CLASS_TYPE &
+CLASS_TYPE::operator ++ () // prefix
+{
+    *this = *this + 1;
+    return *this;
+}
+
+
+const CLASS_TYPE
+CLASS_TYPE::operator ++ (int) // postfix
+{
+    // Copy digit into d.
+
+#ifdef SC_MAX_NBITS
+    sc_digit d[MAX_NDIGITS];
+#else
+    sc_digit *d = new sc_digit[ndigits];
+#endif
+
+    small_type s = sgn;
+
+    vec_copy(ndigits, d, digit);
+
+    *this = *this + 1;
+
+    return CLASS_TYPE(s, nbits, ndigits, d);
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator += (int64 v)
+{
+    // u = *this
+
+    if (sgn == SC_ZERO) // case 1
+        return (*this = v);
+
+    if (v == 0) // case 2
+        return *this;
+
+    CONVERT_INT64(v);
+
+    // cases 3 and 4
+    add_on_help(sgn, nbits, ndigits, digit,
+                vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+    convert_SM_to_2C_to_SM();
+
+    return *this;
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator += (uint64 v)
+{
+    // u = *this
+
+    if (sgn == SC_ZERO) // case 1
+        return (*this = v);
+
+    if (v == 0)  // case 2
+        return *this;
+
+    CONVERT_INT64(v);
+
+    // cases 3 and 4
+    add_on_help(sgn, nbits, ndigits, digit,
+                vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+    convert_SM_to_2C_to_SM();
+
+    return *this;
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator += (long v)
+{
+    // u = *this
+
+    if (sgn == SC_ZERO) // case 1
+        return (*this = v);
+
+    if (v == 0) // case 2
+        return *this;
+
+    CONVERT_LONG(v);
+
+    // cases 3 and 4
+    add_on_help(sgn, nbits, ndigits, digit,
+                vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+
+    convert_SM_to_2C_to_SM();
+
+    return *this;
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator += (unsigned long v)
+{
+    // u = *this
+
+    if (sgn == SC_ZERO) // case 1
+        return (*this = v);
+
+    if (v == 0) // case 2
+        return *this;
+
+    CONVERT_LONG(v);
+
+    // cases 3 and 4
+    add_on_help(sgn, nbits, ndigits, digit,
+                vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+
+    convert_SM_to_2C_to_SM();
+
+    return *this;
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: MINUS operators: -, -=, --
+// ----------------------------------------------------------------------------
+
+// Cases to consider when computing u + v:
+// 1. u - 0 = u
+// 2. 0 - v = -v
+// 3. if sgn(u) != sgn(v)
+//    3.1 u - (-v) = u + v = sgn(u) * (u + v)
+//    3.2 (-u) - v = -(u + v) ==> sgn(u) * (u + v)
+// 4. if sgn(u) == sgn(v)
+//    4.1 u - v = +(u - v) = sgn(u) * (u - v)
+//    4.2 (-u) - (-v) = -(u - v) = sgn(u) * (u - v)
+//
+// Specialization of above cases for computing --u or u--:
+// 1. 0 - 1 = -1
+// 3. (-u) - 1 = -(u + 1) = sgn(u) * (u + 1)
+// 4. u - 1 = u - 1 = sgn(u) * (u - 1)
+
+const CLASS_TYPE &
+CLASS_TYPE::operator -= (const CLASS_TYPE &v)
+{
+    // u = *this
+    if (v.sgn == SC_ZERO) // case 1
+        return *this;
+    if (sgn == SC_ZERO) { // case 2
+        sgn = -v.sgn;
+        copy_digits(v.nbits, v.ndigits, v.digit);
+    } else {
+        // cases 3 and 4
+        add_on_help(sgn, nbits, ndigits, digit,
+                  -v.sgn, v.nbits, v.ndigits, v.digit);
+        convert_SM_to_2C_to_SM();
+    }
+
+    return *this;
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator -= (const OTHER_CLASS_TYPE &v)
+{
+    // u = *this
+    if (v.sgn == SC_ZERO) // case 1
+        return *this;
+    if (sgn == SC_ZERO) { // case 2
+        sgn = -v.sgn;
+        copy_digits(v.nbits, v.ndigits, v.digit);
+    } else {
+        // cases 3 and 4
+        add_on_help(sgn, nbits, ndigits, digit,
+                  -v.sgn, v.nbits, v.ndigits, v.digit);
+
+        convert_SM_to_2C_to_SM();
+    }
+    return *this;
+}
+
+CLASS_TYPE &
+CLASS_TYPE::operator -- () // prefix
+{
+    *this = *this - 1;
+    return *this;
+}
+
+const CLASS_TYPE
+CLASS_TYPE::operator -- (int) // postfix
+{
+    // Copy digit into d.
+#ifdef SC_MAX_NBITS
+    sc_digit d[MAX_NDIGITS];
+#else
+    sc_digit *d = new sc_digit[ndigits];
+#endif
+    small_type s = sgn;
+    vec_copy(ndigits, d, digit);
+    *this = *this - 1;
+    return CLASS_TYPE(s, nbits, ndigits, d);
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator -= (int64 v)
+{
+    // u = *this
+    if (v == 0) // case 1
+        return *this;
+    if (sgn == SC_ZERO) // case 2
+        return (*this = -v);
+
+    CONVERT_INT64(v);
+
+    // cases 3 and 4
+    add_on_help(sgn, nbits, ndigits, digit,
+                -vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+    convert_SM_to_2C_to_SM();
+
+    return *this;
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator -= (uint64 v)
+{
+    // u = *this
+
+    if (v == 0) // case 1
+        return *this;
+
+    int64 v2 = (int64) v;
+
+    if (sgn == SC_ZERO) // case 2
+        return (*this = -v2);
+
+    CONVERT_INT64(v);
+
+    // cases 3 and 4
+    add_on_help(sgn, nbits, ndigits, digit,
+                -vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+    convert_SM_to_2C_to_SM();
+
+    return *this;
+}
+
+const CLASS_TYPE &
+CLASS_TYPE::operator -= (long v)
+{
+    // u = *this
+
+    if (v == 0) // case 1
+        return *this;
+
+    if (sgn == SC_ZERO) // case 2
+        return (*this = -v);
+
+    CONVERT_LONG(v);
+
+    // cases 3 and 4
+    add_on_help(sgn, nbits, ndigits, digit,
+                -vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+
+    convert_SM_to_2C_to_SM();
+
+    return *this;
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator -= (unsigned long v)
+{
+    // u = *this
+
+    if (v == 0) // case 1
+        return *this;
+
+    long v2 = (long) v;
+
+    if (sgn == SC_ZERO) // case 2
+        return (*this = -v2);
+
+    CONVERT_LONG(v);
+
+    // cases 3 and 4
+    add_on_help(sgn, nbits, ndigits, digit,
+                -vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+
+    convert_SM_to_2C_to_SM();
+
+    return *this;
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: MULTIPLICATION operators: *, *=
+// ----------------------------------------------------------------------------
+
+// Cases to consider when computing u * v:
+// 1. u * 0 = 0 * v = 0
+// 2. 1 * v = v and -1 * v = -v
+// 3. u * 1 = u and u * -1 = -u
+// 4. u * v = u * v
+
+const CLASS_TYPE &
+CLASS_TYPE::operator *= (const CLASS_TYPE &v)
+{
+    // u = *this
+
+    sgn = mul_signs(sgn, v.sgn);
+
+    if (sgn == SC_ZERO) { // case 1
+        vec_zero(ndigits, digit);
+    } else {
+        // cases 2-4
+        MUL_ON_HELPER(sgn,    nbits, ndigits, digit,
+                      v.nbits, v.ndigits, v.digit);
+    }
+
+    return *this;
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator *= (const OTHER_CLASS_TYPE &v)
+{
+    // u = *this
+
+    sgn = mul_signs(sgn, v.sgn);
+
+    if (sgn == SC_ZERO) { // case 1
+        vec_zero(ndigits, digit);
+    } else {
+        // cases 2-4
+        MUL_ON_HELPER(sgn,    nbits, ndigits, digit,
+                      v.nbits, v.ndigits, v.digit);
+    }
+
+    return *this;
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator *= (int64 v)
+{
+    // u = *this
+
+    sgn = mul_signs(sgn, get_sign(v));
+
+    if (sgn == SC_ZERO) { // case 1
+        vec_zero(ndigits, digit);
+    } else { // cases 2-4
+        CONVERT_INT64_2(v);
+        MUL_ON_HELPER(sgn, nbits, ndigits, digit,
+                      BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+    }
+
+    return *this;
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator *= (uint64 v)
+{
+    // u = *this
+    sgn = mul_signs(sgn, get_sign(v));
+
+    if (sgn == SC_ZERO) { // case 1
+        vec_zero(ndigits, digit);
+    } else { // cases 2-4
+        CONVERT_INT64_2(v);
+        MUL_ON_HELPER(sgn,    nbits, ndigits, digit,
+                      BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+    }
+
+    return *this;
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator *= (long v)
+{
+    // u = *this
+
+    sgn = mul_signs(sgn, get_sign(v));
+
+    if (sgn == SC_ZERO) { // case 1
+        vec_zero(ndigits, digit);
+    } else { // cases 2-4
+        CONVERT_LONG_2(v);
+        MUL_ON_HELPER(sgn,    nbits, ndigits, digit,
+                      BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+    }
+    return *this;
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator *= (unsigned long v)
+{
+    // u = *this
+
+    sgn = mul_signs(sgn, get_sign(v));
+
+    if (sgn == SC_ZERO) { // case 1
+        vec_zero(ndigits, digit);
+    } else { // cases 2-4
+        CONVERT_LONG_2(v);
+        MUL_ON_HELPER(sgn,    nbits, ndigits, digit,
+                      BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+    }
+
+    return *this;
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: DIVISION operators: /, /=
+// ----------------------------------------------------------------------------
+
+// Cases to consider when finding the quotient q = floor(u/v):
+// Note that u = q * v + r for r < q.
+// 1. 0 / 0 or u / 0 => error
+// 2. 0 / v => 0 = 0 * v + 0
+// 3. u / v && u = v => u = 1 * u + 0  - u or v can be 1 or -1
+// 4. u / v && u < v => u = 0 * v + u  - u can be 1 or -1
+// 5. u / v && u > v => u = q * v + r  - v can be 1 or -1
+
+const CLASS_TYPE &
+CLASS_TYPE::operator /= (const CLASS_TYPE &v)
+{
+    sgn = mul_signs(sgn, v.sgn);
+
+    if (sgn == SC_ZERO) {
+        div_by_zero(v.sgn); // case 1
+        vec_zero(ndigits, digit); // case 2
+    } else { // other cases
+        DIV_ON_HELPER(sgn, nbits, ndigits, digit,
+                      v.nbits, v.ndigits, v.digit);
+    }
+    return *this;
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator /= (const OTHER_CLASS_TYPE &v)
+{
+    sgn = mul_signs(sgn, v.sgn);
+
+    if (sgn == SC_ZERO) {
+        div_by_zero(v.sgn); // case 1
+        vec_zero(ndigits, digit); // case 2
+    } else { // other cases
+        DIV_ON_HELPER(sgn, nbits, ndigits, digit,
+                      v.nbits, v.ndigits, v.digit);
+    }
+    return *this;
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator /= (int64 v)
+{
+    // u = *this
+
+    sgn = mul_signs(sgn, get_sign(v));
+
+    if (sgn == SC_ZERO) {
+        div_by_zero(v); // case 1
+        vec_zero(ndigits, digit); // case 2
+    } else {
+        CONVERT_INT64_2(v);
+        // other cases
+        DIV_ON_HELPER(sgn, nbits, ndigits, digit,
+                      BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+    }
+    return *this;
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator /= (uint64 v)
+{
+    // u = *this
+
+    sgn = mul_signs(sgn, get_sign(v));
+
+    if (sgn == SC_ZERO) {
+        div_by_zero(v); // case 1
+        vec_zero(ndigits, digit); // case 2
+    } else {
+        CONVERT_INT64_2(v);
+        // other cases
+        DIV_ON_HELPER(sgn, nbits, ndigits, digit,
+                  BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+    }
+    return *this;
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator /= (long v)
+{
+    // u = *this
+
+    sgn = mul_signs(sgn, get_sign(v));
+
+    if (sgn == SC_ZERO) {
+        div_by_zero(v); // case 1
+        vec_zero(ndigits, digit); // case 2
+    } else {
+        CONVERT_LONG_2(v);
+        // other cases
+        DIV_ON_HELPER(sgn,    nbits, ndigits, digit,
+                      BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+    }
+    return *this;
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator /= (unsigned long v)
+{
+    // u = *this
+
+    sgn = mul_signs(sgn, get_sign(v));
+
+    if (sgn == SC_ZERO) {
+        div_by_zero(v); // case 1
+        vec_zero(ndigits, digit); // case 2
+    } else {
+        CONVERT_LONG_2(v);
+        // other cases
+        DIV_ON_HELPER(sgn,    nbits, ndigits, digit,
+                      BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+    }
+    return *this;
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: MOD operators: %, %=.
+// ----------------------------------------------------------------------------
+
+// Cases to consider when finding the remainder r = u % v:
+// Note that u = q * v + r for r < q.
+// 1. 0 % 0 or u % 0 => error
+// 2. 0 % v => 0 = 0 * v + 0
+// 3. u % v && u = v => u = 1 * u + 0  - u or v can be 1 or -1
+// 4. u % v && u < v => u = 0 * v + u  - u can be 1 or -1
+// 5. u % v && u > v => u = q * v + r  - v can be 1 or -1
+
+const CLASS_TYPE &
+CLASS_TYPE::operator %= (const CLASS_TYPE &v)
+{
+    if ((sgn == SC_ZERO) || (v.sgn == SC_ZERO)) {
+        div_by_zero(v.sgn); // case 1
+        vec_zero(ndigits, digit); // case 2
+    } else { // other cases
+        MOD_ON_HELPER(sgn, nbits, ndigits, digit,
+                      v.nbits, v.ndigits, v.digit);
+    }
+    return *this;
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator %= (const OTHER_CLASS_TYPE &v)
+{
+    if ((sgn == SC_ZERO) || (v.sgn == SC_ZERO)) {
+        div_by_zero(v.sgn); // case 1
+        vec_zero(ndigits, digit); // case 2
+    } else { // other cases
+        MOD_ON_HELPER(sgn, nbits, ndigits, digit,
+                      v.nbits, v.ndigits, v.digit);
+    }
+
+    return *this;
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator %= (int64 v)
+{
+    small_type vs = get_sign(v);
+
+    if ((sgn == SC_ZERO) || (vs == SC_ZERO)) {
+        div_by_zero(v); // case 1
+        vec_zero(ndigits, digit); // case 2
+    } else {
+        CONVERT_INT64_2(v);
+        // other cases
+        MOD_ON_HELPER(sgn, nbits, ndigits, digit,
+                      BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+    }
+    return *this;
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator %= (uint64 v)
+{
+    if ((sgn == SC_ZERO) || (v == 0)) {
+        div_by_zero(v); // case 1
+        vec_zero(ndigits, digit); // case 2
+    } else {
+        CONVERT_INT64_2(v);
+        // other cases
+        MOD_ON_HELPER(sgn, nbits, ndigits, digit,
+                      BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+    }
+    return *this;
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator %= (long v)
+{
+    small_type vs = get_sign(v);
+
+    if ((sgn == SC_ZERO) || (vs == SC_ZERO)) {
+        div_by_zero(v); // case 1
+        vec_zero(ndigits, digit); // case 2
+    } else {
+        CONVERT_LONG_2(v);
+        // other cases
+        MOD_ON_HELPER(sgn, nbits, ndigits, digit,
+                      BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+    }
+    return *this;
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator %= (unsigned long v)
+{
+    if ((sgn == SC_ZERO) || (v == 0)) {
+        div_by_zero(v); // case 1
+        vec_zero(ndigits, digit); // case 2
+    } else {
+        CONVERT_LONG_2(v);
+        // other cases
+        MOD_ON_HELPER(sgn, nbits, ndigits, digit,
+                      BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+    }
+    return *this;
+}
+
+
+// ----------------------------------------------------------------------------
+//    SECTION: Bitwise AND operators: &, &=
+// ----------------------------------------------------------------------------
+
+// Cases to consider when computing u    &v:
+// 1. u & 0 = 0    &v = 0
+// 2. u    &v => sgn = +
+// 3. (-u) & (-v) => sgn = -
+// 4. u & (-v) => sgn = +
+// 5. (-u)    &v => sgn = +
+
+const CLASS_TYPE &
+CLASS_TYPE::operator &= (const CLASS_TYPE &v)
+{
+    // u = *this
+    if ((sgn == SC_ZERO) || (v.sgn == SC_ZERO)) { // case 1
+        makezero();
+    } else { // other cases
+        and_on_help(sgn, nbits, ndigits, digit,
+                    v.sgn, v.nbits, v.ndigits, v.digit);
+        convert_2C_to_SM();
+    }
+    return *this;
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator &= (const OTHER_CLASS_TYPE &v)
+{
+    // u = *this
+
+    if ((sgn == SC_ZERO) || (v.sgn == SC_ZERO)) { // case 1
+        makezero();
+    } else { // other cases
+        and_on_help(sgn, nbits, ndigits, digit,
+                    v.sgn, v.nbits, v.ndigits, v.digit);
+        convert_2C_to_SM();
+    }
+    return *this;
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator &= (int64 v)
+{
+    // u = *this
+    if ((sgn == SC_ZERO) || (v == 0)) { // case 1
+        makezero();
+    } else { // other cases
+        CONVERT_INT64(v);
+        and_on_help(sgn, nbits, ndigits, digit,
+                    vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+        convert_2C_to_SM();
+    }
+    return *this;
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator &= (uint64 v)
+{
+    // u = *this
+    if ((sgn == SC_ZERO) || (v == 0)) { // case 1
+        makezero();
+    } else { // other cases
+        CONVERT_INT64(v);
+        and_on_help(sgn, nbits, ndigits, digit,
+                    vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+        convert_2C_to_SM();
+    }
+    return *this;
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator &= (long v)
+{
+    // u = *this
+
+    if ((sgn == SC_ZERO) || (v == 0)) { // case 1
+        makezero();
+    } else { // other cases
+        CONVERT_LONG(v);
+        and_on_help(sgn, nbits, ndigits, digit,
+                    vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+        convert_2C_to_SM();
+    }
+
+    return *this;
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator &= (unsigned long v)
+{
+    // u = *this
+    if ((sgn == SC_ZERO) || (v == 0)) { // case 1
+        makezero();
+    } else { // other cases
+        CONVERT_LONG(v);
+        and_on_help(sgn, nbits, ndigits, digit,
+                    vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+        convert_2C_to_SM();
+    }
+    return *this;
+}
+
+
+// ----------------------------------------------------------------------------
+//    SECTION: Bitwise OR operators: |, |=
+// ----------------------------------------------------------------------------
+
+// Cases to consider when computing u | v:
+// 1. u | 0 = u
+// 2. 0 | v = v
+// 3. u | v => sgn = +
+// 4. (-u) | (-v) => sgn = -
+// 5. u | (-v) => sgn = -
+// 6. (-u) | v => sgn = -
+
+const CLASS_TYPE &
+CLASS_TYPE::operator |= (const CLASS_TYPE &v)
+{
+    if (v.sgn == SC_ZERO) // case 1
+        return *this;
+    if (sgn == SC_ZERO) // case 2
+        return (*this = v);
+    // other cases
+    or_on_help(sgn, nbits, ndigits, digit,
+               v.sgn, v.nbits, v.ndigits, v.digit);
+    convert_2C_to_SM();
+    return *this;
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator |= (const OTHER_CLASS_TYPE &v)
+{
+    if (v.sgn == SC_ZERO) // case 1
+        return *this;
+    if (sgn == SC_ZERO) // case 2
+        return (*this = v);
+    // other cases
+    or_on_help(sgn, nbits, ndigits, digit,
+               v.sgn, v.nbits, v.ndigits, v.digit);
+    convert_2C_to_SM();
+    return *this;
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator |= (int64 v)
+{
+    if (v == 0) // case 1
+        return *this;
+    if (sgn == SC_ZERO) // case 2
+        return (*this = v);
+    // other cases
+    CONVERT_INT64(v);
+    or_on_help(sgn, nbits, ndigits, digit,
+               vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+    convert_2C_to_SM();
+    return *this;
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator |= (uint64 v)
+{
+    if (v == 0) // case 1
+        return *this;
+    if (sgn == SC_ZERO) // case 2
+        return (*this = v);
+    // other cases
+    CONVERT_INT64(v);
+    or_on_help(sgn, nbits, ndigits, digit,
+               vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+    convert_2C_to_SM();
+    return *this;
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator |= (long v)
+{
+    if (v == 0) // case 1
+        return *this;
+    if (sgn == SC_ZERO) // case 2
+        return (*this = v);
+    // other cases
+    CONVERT_LONG(v);
+    or_on_help(sgn, nbits, ndigits, digit,
+               vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+    convert_2C_to_SM();
+    return *this;
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator |= (unsigned long v)
+{
+    if (v == 0) // case 1
+        return *this;
+    if (sgn == SC_ZERO) // case 2
+        return (*this = v);
+    // other cases
+    CONVERT_LONG(v);
+    or_on_help(sgn, nbits, ndigits, digit,
+               vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+    convert_2C_to_SM();
+    return *this;
+}
+
+
+// ----------------------------------------------------------------------------
+//    SECTION: Bitwise XOR operators: ^, ^=
+// ----------------------------------------------------------------------------
+
+// Cases to consider when computing u ^ v:
+// Note that    u ^ v = (~u    &v) | (u & ~v).
+// 1. u ^ 0 = u
+// 2. 0 ^ v = v
+// 3. u ^ v => sgn = +
+// 4. (-u) ^ (-v) => sgn = -
+// 5. u ^ (-v) => sgn = -
+// 6. (-u) ^ v => sgn = +
+
+const CLASS_TYPE &
+CLASS_TYPE::operator ^= (const CLASS_TYPE &v)
+{
+    // u = *this
+    if (v.sgn == SC_ZERO) // case 1
+        return *this;
+    if (sgn == SC_ZERO) // case 2
+        return (*this = v);
+    // other cases
+    xor_on_help(sgn, nbits, ndigits, digit,
+                v.sgn, v.nbits, v.ndigits, v.digit);
+    convert_2C_to_SM();
+    return *this;
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator ^= (const OTHER_CLASS_TYPE &v)
+{
+    // u = *this
+    if (v.sgn == SC_ZERO) // case 1
+        return *this;
+    if (sgn == SC_ZERO) // case 2
+        return (*this = v);
+    // other cases
+    xor_on_help(sgn, nbits, ndigits, digit,
+                v.sgn, v.nbits, v.ndigits, v.digit);
+    convert_2C_to_SM();
+    return *this;
+}
+
+
+const CLASS_TYPE&
+CLASS_TYPE::operator ^= (int64 v)
+{
+    if (v == 0) // case 1
+        return *this;
+    if (sgn == SC_ZERO) // case 2
+        return (*this = v);
+    // other cases
+    CONVERT_INT64(v);
+    xor_on_help(sgn, nbits, ndigits, digit,
+                vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+    convert_2C_to_SM();
+    return *this;
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator ^= (uint64 v)
+{
+    if (v == 0) // case 1
+        return *this;
+    if (sgn == SC_ZERO) // case 2
+        return (*this = v);
+    // other cases
+    CONVERT_INT64(v);
+    xor_on_help(sgn, nbits, ndigits, digit,
+                vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+    convert_2C_to_SM();
+    return *this;
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator ^= (long v)
+{
+    if (v == 0) // case 1
+        return *this;
+    if (sgn == SC_ZERO) // case 2
+        return (*this = v);
+    // other cases
+    CONVERT_LONG(v);
+    xor_on_help(sgn, nbits, ndigits, digit,
+                vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+    convert_2C_to_SM();
+    return *this;
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator ^= (unsigned long v)
+{
+    if (v == 0) // case 1
+        return *this;
+    if (sgn == SC_ZERO) // case 2
+        return (*this = v);
+    // other cases
+    CONVERT_LONG(v);
+    xor_on_help(sgn, nbits, ndigits, digit,
+                vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+    convert_2C_to_SM();
+    return *this;
+}
+
+
+// ----------------------------------------------------------------------------
+//    SECTION: Bitwise NOT operator: ~
+// ----------------------------------------------------------------------------
+
+CLASS_TYPE
+operator ~ (const CLASS_TYPE &u)
+{
+    small_type s = u.sgn;
+    if (s == SC_ZERO) {
+        sc_digit d = 1;
+        return CLASS_TYPE(SC_NEG, u.nbits, 1, &d, false);
+    }
+
+    int nd = u.ndigits;
+
+#ifdef SC_MAX_NBITS
+    sc_digit d[MAX_NDIGITS];
+#else
+    sc_digit *d = new sc_digit[nd];
+#endif
+
+    vec_copy(nd, d, u.digit);
+    if (s == SC_POS) {
+        s = SC_NEG;
+        vec_add_small_on(nd, d, 1);
+    } else {
+        s = SC_POS;
+        vec_sub_small_on(nd, d, 1);
+        if (check_for_zero(nd, d))
+            s = SC_ZERO;
+    }
+    return CLASS_TYPE(s, u.nbits, nd, d);
+}
+
+
+// ----------------------------------------------------------------------------
+//    SECTION: LEFT SHIFT operators: <<, <<=
+// ----------------------------------------------------------------------------
+
+CLASS_TYPE
+operator << (const CLASS_TYPE &u, const CLASS_TYPE &v)
+{
+    if (v.sgn == SC_ZERO)
+        return CLASS_TYPE(u);
+#ifdef SC_SIGNED
+    if (v.sgn == SC_NEG)
+        return CLASS_TYPE(u);
+#endif
+    return operator << (u, v.to_ulong());
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator <<= (const CLASS_TYPE &v)
+{
+    if (v.sgn == SC_ZERO)
+        return *this;
+#ifdef SC_SIGNED
+    if (v.sgn == SC_NEG)
+        return *this;
+#endif
+    return operator <<= (v.to_ulong());
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator <<= (const OTHER_CLASS_TYPE &v)
+{
+    if (v.sgn == SC_ZERO)
+        return *this;
+#ifdef SC_UNSIGNED
+    if (v.sgn == SC_NEG)
+        return *this;
+#endif
+    return operator <<= (v.to_ulong());
+}
+
+
+CLASS_TYPE
+operator << (const CLASS_TYPE &u, int64 v)
+{
+    if (v <= 0)
+        return CLASS_TYPE(u);
+    return operator << (u, (unsigned long)v);
+}
+
+
+CLASS_TYPE
+operator << (const CLASS_TYPE &u, uint64 v)
+{
+    if (v == 0)
+        return CLASS_TYPE(u);
+    return operator << (u, (unsigned long)v);
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator <<= (int64 v)
+{
+    if (v <= 0)
+        return *this;
+    return operator <<= ((unsigned long)v);
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator <<= (uint64 v)
+{
+    if (v == 0)
+        return *this;
+    return operator <<= ((unsigned long)v);
+}
+
+
+CLASS_TYPE
+operator << (const CLASS_TYPE &u, long v)
+{
+    if (v <= 0)
+        return CLASS_TYPE(u);
+    return operator << (u, (unsigned long)v);
+}
+
+CLASS_TYPE
+operator << (const CLASS_TYPE &u, unsigned long v)
+{
+    if (v == 0)
+        return CLASS_TYPE(u);
+    if (u.sgn == SC_ZERO)
+        return CLASS_TYPE(u);
+
+    int nb = u.nbits + v;
+    int nd = DIV_CEIL(nb);
+
+#ifdef SC_MAX_NBITS
+    test_bound(nb);
+    sc_digit d[MAX_NDIGITS];
+#else
+    sc_digit *d = new sc_digit[nd];
+#endif
+
+    vec_copy_and_zero(nd, d, u.ndigits, u.digit);
+    convert_SM_to_2C(u.sgn, nd, d);
+    vec_shift_left(nd, d, v);
+    small_type s = convert_signed_2C_to_SM(nb, nd, d);
+    return CLASS_TYPE(s, nb, nd, d);
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator <<= (long v)
+{
+    if (v <= 0)
+        return *this;
+    return operator <<= ((unsigned long)v);
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator <<= (unsigned long v)
+{
+    if (v == 0)
+        return *this;
+    if (sgn == SC_ZERO)
+        return *this;
+    convert_SM_to_2C();
+    vec_shift_left(ndigits, digit, v);
+    convert_2C_to_SM();
+    return *this;
+}
+
+
+// ----------------------------------------------------------------------------
+//    SECTION: RIGHT SHIFT operators: >>, >>=
+// ----------------------------------------------------------------------------
+
+CLASS_TYPE
+operator >> (const CLASS_TYPE &u, const CLASS_TYPE &v)
+{
+    if (v.sgn == SC_ZERO)
+        return CLASS_TYPE(u);
+#ifdef SC_SIGNED
+    if (v.sgn == SC_NEG)
+        return CLASS_TYPE(u);
+#endif
+    return operator >> (u, v.to_long());
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator >>= (const CLASS_TYPE &v)
+{
+    if (v.sgn == SC_ZERO)
+        return *this;
+#ifdef SC_SIGNED
+    if (v.sgn == SC_NEG)
+        return *this;
+#endif
+    return operator >>= (v.to_long());
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator >>= (const OTHER_CLASS_TYPE &v)
+{
+    if (v.sgn == SC_ZERO)
+        return *this;
+#ifdef SC_UNSIGNED
+    if (v.sgn == SC_NEG)
+        return *this;
+#endif
+    return operator >>= (v.to_ulong());
+}
+
+
+CLASS_TYPE
+operator >> (const CLASS_TYPE &u, int64 v)
+{
+    if (v <= 0)
+        return CLASS_TYPE(u);
+    return operator >> (u, (unsigned long)v);
+}
+
+
+CLASS_TYPE
+operator >> (const CLASS_TYPE &u, uint64 v)
+{
+    if (v == 0)
+        return CLASS_TYPE(u);
+    return operator >> (u, (unsigned long)v);
+}
+
+const CLASS_TYPE &
+CLASS_TYPE::operator >>= (int64 v)
+{
+    if (v <= 0)
+        return *this;
+    return operator >>= ((unsigned long)v);
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator >>= (uint64 v)
+{
+    if (v == 0)
+        return *this;
+    return operator >>= ((unsigned long)v);
+}
+
+
+CLASS_TYPE
+operator >> (const CLASS_TYPE &u, long v)
+{
+    if (v <= 0)
+        return CLASS_TYPE(u);
+    return operator >> (u, (unsigned long)v);
+}
+
+
+CLASS_TYPE
+operator >> (const CLASS_TYPE &u, unsigned long v)
+{
+    if (v == 0)
+        return CLASS_TYPE(u);
+    if (u.sgn == SC_ZERO)
+        return CLASS_TYPE(u);
+
+    int nb = u.nbits;
+    int nd = u.ndigits;
+
+#ifdef SC_MAX_NBITS
+    sc_digit d[MAX_NDIGITS];
+#else
+    sc_digit *d = new sc_digit[nd];
+#endif
+
+    vec_copy(nd, d, u.digit);
+    convert_SM_to_2C(u.sgn, nd, d);
+    if (u.sgn == SC_NEG)
+        vec_shift_right(nd, d, v, DIGIT_MASK);
+    else
+        vec_shift_right(nd, d, v, 0);
+    small_type s = convert_signed_2C_to_SM(nb, nd, d);
+    return CLASS_TYPE(s, nb, nd, d);
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator >>= (long v)
+{
+    if (v <= 0)
+        return *this;
+    return operator >>= ((unsigned long)v);
+}
+
+
+const CLASS_TYPE &
+CLASS_TYPE::operator >>= (unsigned long v)
+{
+    if (v == 0)
+        return *this;
+    if (sgn == SC_ZERO)
+        return *this;
+
+    convert_SM_to_2C();
+
+    if (sgn == SC_NEG)
+        vec_shift_right(ndigits, digit, v, DIGIT_MASK);
+    else
+        vec_shift_right(ndigits, digit, v, 0);
+    convert_2C_to_SM();
+    return *this;
+}
+
+
+// ----------------------------------------------------------------------------
+//    SECTION: EQUAL TO operator: ==
+// ----------------------------------------------------------------------------
+
+// Defined in the sc_signed.cpp and sc_unsigned.cpp.
+
+
+// ----------------------------------------------------------------------------
+//    SECTION: NOT_EQUAL operator: !=
+// ----------------------------------------------------------------------------
+
+bool
+operator != (const CLASS_TYPE &u, const CLASS_TYPE &v)
+{
+    return (!operator == (u, v));
+}
+
+
+bool
+operator != (const CLASS_TYPE &u, int64 v)
+{
+    return (!operator == (u, v));
+}
+
+
+bool
+operator != (int64 u, const CLASS_TYPE &v)
+{
+    return (!operator == (u, v));
+}
+
+
+bool
+operator != (const CLASS_TYPE &u, uint64 v)
+{
+    return (!operator == (u, v));
+}
+
+
+bool
+operator != (uint64 u, const CLASS_TYPE &v)
+{
+    return (!operator == (u, v));
+}
+
+
+bool
+operator != (const CLASS_TYPE &u, long v)
+{
+    return (!operator == (u, v));
+}
+
+
+bool
+operator != (long u, const CLASS_TYPE &v)
+{
+    return (!operator == (u, v));
+}
+
+
+bool
+operator != (const CLASS_TYPE &u, unsigned long v)
+{
+    return (!operator == (u, v));
+}
+
+
+bool
+operator != (unsigned long u, const CLASS_TYPE &v)
+{
+    return (!operator == (u, v));
+}
+
+
+// ----------------------------------------------------------------------------
+//    SECTION: LESS THAN operator: <
+// ----------------------------------------------------------------------------
+
+// Defined in the sc_signed.cpp and sc_unsigned.cpp.
+
+
+// ----------------------------------------------------------------------------
+//    SECTION: LESS THAN or EQUAL operator: <=
+// ----------------------------------------------------------------------------
+
+bool
+operator <= (const CLASS_TYPE &u, const CLASS_TYPE &v)
+{
+    return (operator < (u, v) || operator == (u, v));
+}
+
+
+bool
+operator <= (const CLASS_TYPE &u, int64 v)
+{
+    return (operator < (u, v) || operator == (u, v));
+}
+
+
+bool
+operator <= (int64 u, const CLASS_TYPE &v)
+{
+    return (operator < (u, v) || operator == (u, v));
+}
+
+
+bool
+operator <= (const CLASS_TYPE &u, uint64 v)
+{
+    return (operator < (u, v) || operator == (u, v));
+}
+
+
+bool
+operator <= (uint64 u, const CLASS_TYPE &v)
+{
+    return (operator < (u, v) || operator == (u, v));
+}
+
+
+bool
+operator <= (const CLASS_TYPE &u, long v)
+{
+    return (operator < (u, v) || operator == (u, v));
+}
+
+
+bool
+operator <= (long u, const CLASS_TYPE &v)
+{
+    return (operator < (u, v) || operator == (u, v));
+}
+
+
+bool
+operator <= (const CLASS_TYPE &u, unsigned long v)
+{
+    return (operator < (u, v) || operator == (u, v));
+}
+
+
+bool
+operator <= (unsigned long u, const CLASS_TYPE &v)
+{
+    return (operator < (u, v) || operator == (u, v));
+}
+
+
+// ----------------------------------------------------------------------------
+//    SECTION: GREATER THAN operator: >
+// ----------------------------------------------------------------------------
+
+bool
+operator > (const CLASS_TYPE &u, const CLASS_TYPE &v)
+{
+    return (!(operator <= (u, v)));
+}
+
+
+bool
+operator > (const CLASS_TYPE &u, int64 v)
+{
+    return (!(operator <= (u, v)));
+}
+
+
+bool
+operator > (int64 u, const CLASS_TYPE &v)
+{
+    return (!(operator <= (u, v)));
+}
+
+
+bool
+operator > (const CLASS_TYPE &u, uint64 v)
+{
+    return (!(operator <= (u, v)));
+}
+
+
+bool
+operator > (uint64 u, const CLASS_TYPE &v)
+{
+    return (!(operator <= (u, v)));
+}
+
+
+bool
+operator > (const CLASS_TYPE &u, long v)
+{
+    return (!(operator <= (u, v)));
+}
+
+
+bool
+operator > (long u, const CLASS_TYPE &v)
+{
+    return (!(operator <= (u, v)));
+}
+
+
+bool
+operator > (const CLASS_TYPE &u, unsigned long v)
+{
+    return (!(operator <= (u, v)));
+}
+
+
+bool
+operator > (unsigned long u, const CLASS_TYPE &v)
+{
+    return (!(operator <= (u, v)));
+}
+
+
+// ----------------------------------------------------------------------------
+//    SECTION: GREATER THAN or EQUAL operator: >=
+// ----------------------------------------------------------------------------
+
+bool
+operator >= (const CLASS_TYPE &u, const CLASS_TYPE &v)
+{
+    return (!(operator < (u, v)));
+}
+
+
+bool
+operator >= (const CLASS_TYPE &u, int64 v)
+{
+    return (!(operator < (u, v)));
+}
+
+
+bool
+operator >= (int64 u, const CLASS_TYPE &v)
+{
+    return (!(operator < (u, v)));
+}
+
+
+bool
+operator >= (const CLASS_TYPE &u, uint64 v)
+{
+    return (!(operator < (u, v)));
+}
+
+
+bool
+operator >= (uint64 u, const CLASS_TYPE &v)
+{
+    return (!(operator < (u, v)));
+}
+
+
+bool
+operator >= (const CLASS_TYPE &u, long v)
+{
+    return (!(operator < (u, v)));
+}
+
+
+bool
+operator >= (long u, const CLASS_TYPE &v)
+{
+    return (!(operator < (u, v)));
+}
+
+
+bool
+operator >= (const CLASS_TYPE &u, unsigned long v)
+{
+    return (!(operator < (u, v)));
+}
+
+
+bool
+operator >= (unsigned long u, const CLASS_TYPE &v)
+{
+    return (!(operator < (u, v)));
+}
+
+
+// ----------------------------------------------------------------------------
+//    SECTION: Public members - Other utils.
+// ----------------------------------------------------------------------------
+
+// Convert to int64, long, or int.
+#define TO_INTX(RET_TYPE, UP_RET_TYPE) \
+if (sgn == SC_ZERO) \
+    return 0; \
+int vnd = sc_min((int)DIGITS_PER_ ## UP_RET_TYPE, ndigits); \
+RET_TYPE v = 0; \
+while (--vnd >= 0) \
+    v = (v << BITS_PER_DIGIT) + digit[vnd]; \
+if (sgn == SC_NEG) \
+    return -v; \
+else \
+    return v;
+
+
+int64
+CLASS_TYPE::to_int64() const
+{
+    TO_INTX(int64, INT64);
+}
+
+
+long
+CLASS_TYPE::to_long() const
+{
+    TO_INTX(long, LONG);
+}
+
+
+int
+CLASS_TYPE::to_int() const
+{
+    TO_INTX(int, INT);
+}
+
+
+// Convert to unsigned int64, unsigned long or unsigned
+// int. to_uint64, to_ulong, and to_uint have the same body except for
+// the type of v defined inside.
+uint64
+CLASS_TYPE::to_uint64() const
+{
+    if (sgn == SC_ZERO)
+        return 0;
+
+    int vnd = sc_min((int)DIGITS_PER_INT64, ndigits);
+
+    uint64 v = 0;
+
+    if (sgn == SC_NEG) {
+#ifdef SC_MAX_NBITS
+        sc_digit d[MAX_NDIGITS];
+#else
+        sc_digit *d = new sc_digit[ndigits];
+#endif
+        vec_copy(ndigits, d, digit);
+        convert_SM_to_2C_trimmed(IF_SC_SIGNED, sgn, nbits, ndigits, d);
+        while (--vnd >= 0)
+            v = (v << BITS_PER_DIGIT) + d[vnd];
+#ifndef SC_MAX_NBITS
+        delete [] d;
+#endif
+    } else {
+        while (--vnd >= 0)
+            v = (v << BITS_PER_DIGIT) + digit[vnd];
+    }
+    return v;
+}
+
+
+unsigned long
+CLASS_TYPE::to_ulong() const
+{
+    if (sgn == SC_ZERO)
+        return 0;
+
+    int vnd = sc_min((int)DIGITS_PER_LONG, ndigits);
+    unsigned long v = 0;
+
+    if (sgn == SC_NEG) {
+#ifdef SC_MAX_NBITS
+        sc_digit d[MAX_NDIGITS];
+#else
+        sc_digit *d = new sc_digit[ndigits];
+#endif
+        vec_copy(ndigits, d, digit);
+        convert_SM_to_2C_trimmed(IF_SC_SIGNED, sgn, nbits, ndigits, d);
+        while (--vnd >= 0)
+            v = (v << BITS_PER_DIGIT) + d[vnd];
+#ifndef SC_MAX_NBITS
+        delete [] d;
+#endif
+    } else {
+        while (--vnd >= 0)
+            v = (v << BITS_PER_DIGIT) + digit[vnd];
+    }
+    return v;
+}
+
+
+unsigned int
+CLASS_TYPE::to_uint() const
+{
+    if (sgn == SC_ZERO)
+        return 0;
+
+    int vnd = sc_min((int)DIGITS_PER_INT, ndigits);
+    unsigned int v = 0;
+    if (sgn == SC_NEG) {
+#ifdef SC_MAX_NBITS
+        sc_digit d[MAX_NDIGITS];
+#else
+        sc_digit *d = new sc_digit[ndigits];
+#endif
+        vec_copy(ndigits, d, digit);
+        convert_SM_to_2C_trimmed(IF_SC_SIGNED, sgn, nbits, ndigits, d);
+        while (--vnd >= 0)
+            v = (v << BITS_PER_DIGIT) + d[vnd];
+#ifndef SC_MAX_NBITS
+        delete [] d;
+#endif
+    } else {
+        while (--vnd >= 0)
+            v = (v << BITS_PER_DIGIT) + digit[vnd];
+    }
+    return v;
+}
+
+
+// Convert to double.
+double
+CLASS_TYPE::to_double() const
+{
+    if (sgn == SC_ZERO)
+        return (double) 0.0;
+
+    int vnd = ndigits;
+    double v = 0.0;
+    while (--vnd >= 0)
+        v = v * DIGIT_RADIX + digit[vnd];
+    if (sgn == SC_NEG)
+        return -v;
+    else
+        return v;
+}
+
+
+// Return true if the bit i is 1, false otherwise. If i is outside the
+// bounds, return 1/0 according to the sign of the number by assuming
+// that the number has infinite length.
+
+bool
+CLASS_TYPE::test(int i) const
+{
+#ifdef SC_SIGNED
+    if (check_if_outside(i)) {
+        if (sgn == SC_NEG)
+            return 1;
+        else
+            return 0;
+    }
+#else
+    if (check_if_outside(i))
+        return 0;
+#endif
+
+    int bit_num = bit_ord(i);
+    int digit_num = digit_ord(i);
+
+    if (sgn == SC_NEG) {
+#ifdef SC_MAX_NBITS
+        sc_digit d[MAX_NDIGITS];
+#else
+        sc_digit *d = new sc_digit[ndigits];
+#endif
+        vec_copy(ndigits, d, digit);
+        vec_complement(ndigits, d);
+        bool val = ((d[digit_num] & one_and_zeros(bit_num)) != 0);
+#ifndef SC_MAX_NBITS
+        delete [] d;
+#endif
+        return val;
+    } else {
+        return ((digit[digit_num] & one_and_zeros(bit_num)) != 0);
+    }
+}
+
+
+// Set the ith bit with 1.
+void
+CLASS_TYPE::set(int i)
+{
+    if (check_if_outside(i))
+        return;
+
+    int bit_num = bit_ord(i);
+    int digit_num = digit_ord(i);
+
+    convert_SM_to_2C();
+    digit[digit_num] |= one_and_zeros(bit_num);
+    digit[digit_num] &= DIGIT_MASK; // Needed to zero the overflow bits.
+    convert_2C_to_SM();
+}
+
+
+// Set the ith bit with 0, i.e., clear the ith bit.
+void
+CLASS_TYPE::clear(int i)
+{
+    if (check_if_outside(i))
+        return;
+
+    int bit_num = bit_ord(i);
+    int digit_num = digit_ord(i);
+
+    convert_SM_to_2C();
+    digit[digit_num] &= ~(one_and_zeros(bit_num));
+    digit[digit_num] &= DIGIT_MASK; // Needed to zero the overflow bits.
+    convert_2C_to_SM();
+}
+
+
+// Create a mirror image of the number.
+void
+CLASS_TYPE::reverse()
+{
+    convert_SM_to_2C();
+    vec_reverse(length(), ndigits, digit, length() - 1);
+    convert_2C_to_SM();
+}
+
+
+// Get a packed bit representation of the number.
+void
+CLASS_TYPE::get_packed_rep(sc_digit *buf) const
+{
+    int buf_ndigits = (length() - 1) / BITS_PER_DIGIT_TYPE + 1;
+    // Initialize buf to zero.
+    vec_zero(buf_ndigits, buf);
+
+    if (sgn == SC_ZERO)
+        return;
+
+    const sc_digit *digit_or_d;
+#ifdef SC_MAX_NBITS
+    sc_digit d[MAX_NDIGITS];
+#else
+    sc_digit *d = new sc_digit[ndigits];
+#endif
+
+    if (sgn == SC_POS) {
+        digit_or_d = digit;
+    } else {
+        // If sgn is negative, we have to convert digit to its 2's
+        // complement. Since this function is const, we can not do it on
+        // digit. Since buf doesn't have overflow bits, we cannot also do
+        // it on buf. Thus, we have to do the complementation on a copy of
+        // digit, i.e., on d.
+
+        vec_copy(ndigits, d, digit);
+        vec_complement(ndigits, d);
+        buf[buf_ndigits - 1] = ~((sc_digit) 0);
+        digit_or_d = d;
+    }
+
+    // Copy the bits from digit to buf. The division and mod operations
+    // below can be converted to addition/subtraction and comparison
+    // operations at the expense of complicating the code. We can do it
+    // if we see any performance problems.
+
+    for (int i = length() - 1; i >= 0; --i) {
+
+        if ((digit_or_d[digit_ord(i)] &
+                    one_and_zeros(bit_ord(i))) != 0) { // Test.
+            buf[i / BITS_PER_DIGIT_TYPE] |=
+                one_and_zeros(i % BITS_PER_DIGIT_TYPE); // Set.
+        } else {
+            buf[i / BITS_PER_DIGIT_TYPE] &=
+                ~(one_and_zeros(i % BITS_PER_DIGIT_TYPE)); // Clear.
+        }
+    }
+
+#ifndef SC_MAX_NBITS
+    delete[] d;
+#endif
+}
+
+
+// Set a packed bit representation of the number.
+void
+CLASS_TYPE::set_packed_rep(sc_digit *buf)
+{
+    // Initialize digit to zero.
+    vec_zero(ndigits, digit);
+
+    // Copy the bits from buf to digit.
+    for (int i = length() - 1; i >= 0; --i) {
+        if ((buf[i / BITS_PER_DIGIT_TYPE] &
+                 one_and_zeros(i % BITS_PER_DIGIT_TYPE)) != 0) { // Test.
+            digit[digit_ord(i)] |= one_and_zeros(bit_ord(i)); // Set.
+        } else {
+            digit[digit_ord(i)] &= ~(one_and_zeros(bit_ord(i))); // Clear
+        }
+    }
+    convert_2C_to_SM();
+}
+
+
+// ----------------------------------------------------------------------------
+//    SECTION: Private members.
+// ----------------------------------------------------------------------------
+
+// Create a copy of v with sgn s.
+CLASS_TYPE::CLASS_TYPE(const CLASS_TYPE &v, small_type s) :
+    sc_value_base(v), sgn(s), nbits(v.nbits), ndigits(v.ndigits), digit()
+{
+#ifndef SC_MAX_NBITS
+    digit = new sc_digit[ndigits];
+#endif
+    vec_copy(ndigits, digit, v.digit);
+}
+
+
+// Create a copy of v where v is of the different type.
+CLASS_TYPE::CLASS_TYPE(const OTHER_CLASS_TYPE &v, small_type s) :
+    sc_value_base(v), sgn(s), nbits(num_bits(v.nbits)), ndigits(), digit()
+{
+#if (IF_SC_SIGNED == 1)
+    ndigits = v.ndigits;
+#else
+    ndigits = DIV_CEIL(nbits);
+#endif
+
+#ifndef SC_MAX_NBITS
+    digit = new sc_digit[ndigits];
+#endif
+
+    copy_digits(v.nbits, v.ndigits, v.digit);
+}
+
+
+// Create a signed number with (s, nb, nd, d) as its attributes (as
+// defined in class CLASS_TYPE). If alloc is set, delete d.
+CLASS_TYPE::CLASS_TYPE(
+        small_type s, int nb, int nd, sc_digit *d, bool alloc) :
+    sc_value_base(), sgn(s), nbits(num_bits(nb)), ndigits(), digit()
+{
+    ndigits = DIV_CEIL(nbits);
+#ifndef SC_MAX_NBITS
+    digit = new sc_digit[ndigits];
+#endif
+
+    if (ndigits <= nd)
+        vec_copy(ndigits, digit, d);
+    else
+        vec_copy_and_zero(ndigits, digit, nd, d);
+
+#ifndef SC_MAX_NBITS
+    if (alloc)
+        delete [] d;
+#endif
+}
+
+// This constructor is mainly used in finding a "range" of bits from a
+// number of type CLASS_TYPE. The function range(l, r) can have
+// arbitrary precedence between l and r. If l is smaller than r, then
+// the output is the reverse of range(r, l).
+CLASS_TYPE::CLASS_TYPE(const CLASS_TYPE *u, int l, int r) :
+        sc_value_base(), sgn(), nbits(), ndigits(), digit()
+{
+    bool reversed = false;
+
+    if (l < r) {
+        reversed = true;
+        int tmp = l;
+        l = r;
+        r = tmp;
+    }
+
+    // at this point, l >= r
+
+    // make sure that l and r point to the bits of u
+    r = sc_max(r, 0);
+    l = sc_min(l, u->nbits - 1);
+
+    nbits = num_bits(l - r + 1);
+
+    // nbits can still be <= 0 because l and r have just been updated
+    // with the bounds of u.
+
+    // if u == 0 or the range is out of bounds, return 0
+    if (u->sgn == SC_ZERO || nbits <= num_bits(0)) {
+        sgn = SC_ZERO;
+        if (nbits <= num_bits(0)) {
+            nbits = 1;
+        }
+        ndigits = DIV_CEIL(nbits);
+#ifndef SC_MAX_NBITS
+        digit = new sc_digit[ndigits];
+#endif
+        vec_zero(ndigits, digit);
+        return;
+    }
+
+    // The rest will be executed if u is not zero.
+
+    ndigits = DIV_CEIL(nbits);
+
+    // The number of bits up to and including l and r, respectively.
+    int nl = l + 1;
+    int nr = r + 1;
+
+    // The indices of the digits that have lth and rth bits, respectively.
+    int left_digit = DIV_CEIL(nl) - 1;
+    int right_digit = DIV_CEIL(nr) - 1;
+
+    int nd;
+
+    // The range is performed on the 2's complement representation, so
+    // first get the indices for that.
+    if (u->sgn == SC_NEG)
+        nd = left_digit + 1;
+    else
+        nd = left_digit - right_digit + 1;
+
+    // Allocate memory for the range.
+#ifdef SC_MAX_NBITS
+    sc_digit d[MAX_NDIGITS];
+#else
+    digit = new sc_digit[ndigits];
+    sc_digit *d = new sc_digit[nd];
+#endif
+
+    // Getting the range on the 2's complement representation.
+    if (u->sgn == SC_NEG) {
+        vec_copy(nd, d, u->digit);
+        vec_complement(nd, d); // d = -d;
+        vec_shift_right(nd, d, r, DIGIT_MASK);
+    } else {
+        for (int i = right_digit; i <= left_digit; ++i)
+            d[i - right_digit] = u->digit[i];
+        vec_shift_right(nd, d, r - right_digit * BITS_PER_DIGIT, 0);
+    }
+
+    vec_zero(ndigits, digit);
+
+    if (!reversed) {
+        vec_copy(sc_min(nd, ndigits), digit, d);
+    } else {
+        // If l < r, i.e., reversed is set, reverse the bits of digit.    d
+        // will be used as a temporary store. The following code tries to
+        // minimize the use of bit_ord and digit_ord, which use mod and
+        // div operators. Since these operators are function calls to
+        // standard library routines, they are slow. The main idea in
+        // reversing is "read bits out of d from left to right and push
+        // them into digit using right shifting."
+
+        // Take care of the last digit.
+        int nd_less_1 = nd - 1;
+
+        // Deletions will start from the left end and move one position
+        // after each deletion.
+        sc_digit del_mask = one_and_zeros(bit_ord(l - r));
+
+        while (del_mask) {
+            vec_shift_right(ndigits, digit, 1,
+                    ((d[nd_less_1] & del_mask) != 0));
+            del_mask >>= 1;
+        }
+
+        // Take care of the other digits if any.
+
+        // Insertion to digit will always occur at the left end.
+        sc_digit ins_mask = one_and_zeros(BITS_PER_DIGIT - 1);
+
+        for (int j = nd - 2; j >= 0; --j) { // j = nd - 2
+            // Deletions will start from the left end and move one position
+            // after each deletion.
+            del_mask = ins_mask;
+            while (del_mask) {
+                vec_shift_right(ndigits, digit, 1, ((d[j] & del_mask) != 0));
+                del_mask >>= 1;
+            }
+        }
+
+        if (u->sgn == SC_NEG)
+            vec_shift_right(ndigits, digit,
+                            ndigits * BITS_PER_DIGIT - length(), DIGIT_MASK);
+        else
+            vec_shift_right(ndigits, digit,
+                            ndigits * BITS_PER_DIGIT - length(), 0);
+
+
+    } // if reversed.
+
+    convert_2C_to_SM();
+
+#ifndef SC_MAX_NBITS
+    delete [] d;
+#endif
+}
+
+// This constructor is mainly used in finding a "range" of bits from a
+// number of type OTHER_CLASS_TYPE. The function range(l, r) can have
+// arbitrary precedence between l and r. If l is smaller than r, then
+// the output is the reverse of range(r, l).
+CLASS_TYPE::CLASS_TYPE(const OTHER_CLASS_TYPE *u, int l, int r) :
+        sc_value_base(), sgn(), nbits(), ndigits(), digit()
+{
+    bool reversed = false;
+
+    if (l < r) {
+        reversed = true;
+        int tmp = l;
+        l = r;
+        r = tmp;
+    }
+
+    // at this point, l >= r
+
+    // make sure that l and r point to the bits of u
+    r = sc_max(r, 0);
+    l = sc_min(l, u->nbits - 1);
+
+    nbits = num_bits(l - r + 1);
+
+    // nbits can still be <= 0 because l and r have just been updated
+    // with the bounds of u.
+
+    // if u == 0 or the range is out of bounds, return 0
+    if (u->sgn == SC_ZERO || nbits <= num_bits(0)) {
+        sgn = SC_ZERO;
+        if (nbits <= num_bits(0)) {
+            nbits = 1;
+        }
+        ndigits = DIV_CEIL(nbits);
+#ifndef SC_MAX_NBITS
+        digit = new sc_digit[ndigits];
+#endif
+        vec_zero(ndigits, digit);
+        return;
+    }
+
+    // The rest will be executed if u is not zero.
+
+    ndigits = DIV_CEIL(nbits);
+
+    // The number of bits up to and including l and r, respectively.
+    int nl = l + 1;
+    int nr = r + 1;
+
+    // The indices of the digits that have lth and rth bits, respectively.
+    int left_digit = DIV_CEIL(nl) - 1;
+    int right_digit = DIV_CEIL(nr) - 1;
+
+    int nd;
+
+    // The range is performed on the 2's complement representation, so
+    // first get the indices for that.
+    if (u->sgn == SC_NEG)
+        nd = left_digit + 1;
+    else
+        nd = left_digit - right_digit + 1;
+
+    // Allocate memory for the range.
+#ifdef SC_MAX_NBITS
+    sc_digit d[MAX_NDIGITS];
+#else
+    digit = new sc_digit[ndigits];
+    sc_digit *d = new sc_digit[nd];
+#endif
+
+    // Getting the range on the 2's complement representation.
+    if (u->sgn == SC_NEG) {
+        vec_copy(nd, d, u->digit);
+        vec_complement(nd, d); // d = -d;
+        vec_shift_right(nd, d, r, DIGIT_MASK);
+    } else {
+        for (int i = right_digit; i <= left_digit; ++i)
+            d[i - right_digit] = u->digit[i];
+        vec_shift_right(nd, d, r - right_digit * BITS_PER_DIGIT, 0);
+    }
+
+    vec_zero(ndigits, digit);
+
+    if (!reversed) {
+        vec_copy(sc_min(nd, ndigits), digit, d);
+    } else {
+        // If l < r, i.e., reversed is set, reverse the bits of digit.    d
+        // will be used as a temporary store. The following code tries to
+        // minimize the use of bit_ord and digit_ord, which use mod and
+        // div operators. Since these operators are function calls to
+        // standard library routines, they are slow. The main idea in
+        // reversing is "read bits out of d from left to right and push
+        // them into digit using right shifting."
+
+        // Take care of the last digit.
+        int nd_less_1 = nd - 1;
+
+        // Deletions will start from the left end and move one position
+        // after each deletion.
+        sc_digit del_mask = one_and_zeros(bit_ord(l - r));
+
+        while (del_mask) {
+            vec_shift_right(ndigits, digit, 1,
+                    ((d[nd_less_1] & del_mask) != 0));
+            del_mask >>= 1;
+        }
+
+        // Take care of the other digits if any.
+
+        // Insertion to digit will always occur at the left end.
+        sc_digit ins_mask = one_and_zeros(BITS_PER_DIGIT - 1);
+
+        for (int j = nd - 2; j >= 0; --j) { // j = nd - 2
+            // Deletions will start from the left end and move one position
+            // after each deletion.
+            del_mask = ins_mask;
+
+            while (del_mask) {
+                vec_shift_right(ndigits, digit, 1, ((d[j] & del_mask) != 0));
+                del_mask >>= 1;
+            }
+        }
+
+        if (u->sgn == SC_NEG)
+            vec_shift_right(ndigits, digit,
+                            ndigits * BITS_PER_DIGIT - length(), DIGIT_MASK);
+        else
+            vec_shift_right(ndigits, digit,
+                            ndigits * BITS_PER_DIGIT - length(), 0);
+
+
+    } // if reversed.
+
+    convert_2C_to_SM();
+
+#ifndef SC_MAX_NBITS
+    delete [] d;
+#endif
+}
+
+
+// Print out all the physical attributes.
+void
+CLASS_TYPE::dump(::std::ostream &os) const
+{
+    // Save the current setting, and set the base to decimal.
+    ::std::ios::fmtflags old_flags = 
+        os.setf(::std::ios::dec, ::std::ios::basefield);
+
+    os << "width = " << length() << ::std::endl;
+    os << "value = " << *this << ::std::endl;
+    os << "bits = ";
+
+    int len = length();
+
+    for (int i = len - 1; i >= 0; --i) {
+        os << "01"[test(i)];
+        if (--len % 4 == 0)
+            os << " ";
+    }
+
+    os << ::std::endl;
+
+    // Restore old_flags.
+    os.setf(old_flags, ::std::ios::basefield);
+}
+
+
+// Checks to see if bit_num is out of bounds.
+bool
+CLASS_TYPE::check_if_outside(int bit_num) const
+{
+    if ((bit_num < 0) || (num_bits(bit_num) >= nbits)) {
+#ifdef DEBUG_SYSTEMC
+        if (bit_num < 0 || bit_num >= nbits) {
+                std::stringstream msg;
+                msg << CLASS_TYPE_STR "::check_if_outside(int bit_num) : "
+                             "bit_num = " << bit_num << " is out of bounds";
+                SC_REPORT_WARNING(sc_core::SC_ID_OUT_OF_BOUNDS_,
+                                  msg.str().c_str());
+        }
+#endif
+        return true;
+    }
+    return false;
+}
diff --git a/src/systemc/dt/int/sc_nbexterns.cc b/src/systemc/dt/int/sc_nbexterns.cc
new file mode 100644
index 0000000..479e68e
--- /dev/null
+++ b/src/systemc/dt/int/sc_nbexterns.cc
@@ -0,0 +1,739 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_nbexterns.cpp -- External functions for both sc_signed and sc_unsigned
+                      classes. These functions work on two parameters u and
+                      v, and copy the result to the first parameter u. This
+                      is also the reason that they are suffixed with _on_help.
+
+  Original Author: Ali Dasdan, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: sc_nbexterns.cpp,v $
+// Revision 1.2  2011/02/18 20:19:15  acg
+//  Andy Goodrich: updating Copyright notice.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:49:32  acg
+// Added $Log command so that CVS check in comments are reproduced in the
+// source.
+//
+
+#include "systemc/ext/dt/int/sc_nbexterns.hh"
+#include "systemc/ext/utils/functions.hh"
+
+namespace sc_dt
+{
+
+// ----------------------------------------------------------------------------
+//  SECTION: External functions for PLUS operators.
+// ----------------------------------------------------------------------------
+
+// Handles the cases 3 and 4 and returns the result in u.
+void
+add_on_help(small_type &us, int /* unb */, int und, sc_digit *ud,
+            small_type vs, int /* vnb */, int vnd, const sc_digit *vd)
+{
+    vnd = vec_skip_leading_zeros(vnd, vd);
+
+    if (us == vs) {  // case 3
+        if (und >= vnd)
+            vec_add_on(und, ud, vnd, vd);
+        else
+            vec_add_on2(und, ud, vnd, vd);
+
+    } else {  // case 4
+        // vec_cmp expects that und is the number of non-zero digits in ud.
+        int new_und = vec_skip_leading_zeros(und, ud);
+        int cmp_res = vec_cmp(new_und, ud, vnd, vd);
+
+        if (cmp_res == 0) { // u == v
+            us = SC_ZERO;
+            vec_zero(und, ud);
+            return;
+        }
+
+        if (cmp_res > 0) { // u > v
+            vec_sub_on(und, ud, vnd, vd);
+        } else { // u < v
+            us = -us;
+            vec_sub_on2(und, ud, vnd, vd);
+        }
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+
+/*
+
+mul_on_help_signed and mul_on_help_unsigned have the same body except
+that CONVERT_SM_to_2C_to_SM and COPY_DIGITS are defined for signed and
+unsigned, respectively.  This comment also applies to the
+signed/unsigned versions of div_on_help and mod_on_help. It is
+possible to take COPY_DIGITS out of these functions and create a
+single version of each of these helper functions; however, this will
+impose an onverhead on performance. In the versions below, any change
+in the signed version of a helper function must be carried to a
+corresponding change in the unsigned verion of the same function or
+vice versa.
+
+*/
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: External functions of MULTIPLICATION operators.
+// ----------------------------------------------------------------------------
+
+void
+mul_on_help_signed(small_type &us, int unb, int und, sc_digit *ud,
+                   int vnb, int vnd, const sc_digit *vd)
+{
+#define CONVERT_SM_to_2C_to_SM convert_signed_SM_to_2C_to_SM
+#define COPY_DIGITS copy_digits_signed
+    { // Body of mul_on_help
+        int old_und = und;
+
+        und = vec_skip_leading_zeros(und, ud);
+        vnd = vec_skip_leading_zeros(vnd, vd);
+
+        sc_digit ud0 = (*ud);
+        sc_digit vd0 = (*vd);
+
+        if ((vnd == 1) && (vd0 == 1)) {
+            us = CONVERT_SM_to_2C_to_SM(us, unb, old_und, ud);
+            return;
+        }
+
+        if ((und == 1) && (ud0 == 1)) {
+            COPY_DIGITS(us, unb, old_und, ud, vnb, vnd, vd);
+            return;
+        }
+
+        if ((und == 1) && (vnd == 1) &&
+            (ud0 < HALF_DIGIT_RADIX) && (vd0 < HALF_DIGIT_RADIX)) {
+
+            sc_digit d = ud0 * vd0;
+            COPY_DIGITS(us, unb, old_und, ud, unb + vnb, 1, &d);
+            return;
+        }
+
+        int nd = und + vnd;
+
+#ifdef SC_MAX_NBITS
+        sc_digit d[MAX_NDIGITS];
+#else
+        sc_digit *d = new sc_digit[nd];
+#endif
+
+        vec_zero(nd, d);
+
+        if ((und == 1) && (ud0 < HALF_DIGIT_RADIX))
+            vec_mul_small(vnd, vd, ud0, d);
+        else if ((vnd == 1) && (vd0 < HALF_DIGIT_RADIX))
+            vec_mul_small(und, ud, vd0, d);
+        else if (vnd < und)
+            vec_mul(und, ud, vnd, vd, d);
+        else
+            vec_mul(vnd, vd, und, ud, d);
+
+        COPY_DIGITS(us, unb, old_und, ud, unb + vnb, nd, d);
+
+#ifndef SC_MAX_NBITS
+        delete [] d;
+#endif
+    }
+#undef COPY_DIGITS
+#undef CONVERT_SM_to_2C_to_SM
+}
+
+
+void
+mul_on_help_unsigned(small_type &us, int unb, int und, sc_digit *ud,
+                     int vnb, int vnd, const sc_digit *vd)
+{
+#define CONVERT_SM_to_2C_to_SM convert_unsigned_SM_to_2C_to_SM
+#define COPY_DIGITS copy_digits_unsigned
+    { // Body of mul_on_help
+        int old_und = und;
+
+        und = vec_skip_leading_zeros(und, ud);
+        vnd = vec_skip_leading_zeros(vnd, vd);
+
+        sc_digit ud0 = (*ud);
+        sc_digit vd0 = (*vd);
+
+        if ((vnd == 1) && (vd0 == 1)) {
+            us = CONVERT_SM_to_2C_to_SM(us, unb, old_und, ud);
+            return;
+        }
+
+        if ((und == 1) && (ud0 == 1)) {
+            COPY_DIGITS(us, unb, old_und, ud, vnb, vnd, vd);
+            return;
+        }
+
+        if ((und == 1) && (vnd == 1) &&
+            (ud0 < HALF_DIGIT_RADIX) && (vd0 < HALF_DIGIT_RADIX)) {
+
+            sc_digit d = ud0 * vd0;
+            COPY_DIGITS(us, unb, old_und, ud, unb + vnb, 1, &d);
+            return;
+        }
+
+        int nd = und + vnd;
+
+#ifdef SC_MAX_NBITS
+        sc_digit d[MAX_NDIGITS];
+#else
+        sc_digit *d = new sc_digit[nd];
+#endif
+
+        vec_zero(nd, d);
+
+        if ((und == 1) && (ud0 < HALF_DIGIT_RADIX))
+            vec_mul_small(vnd, vd, ud0, d);
+        else if ((vnd == 1) && (vd0 < HALF_DIGIT_RADIX))
+            vec_mul_small(und, ud, vd0, d);
+        else if (vnd < und)
+            vec_mul(und, ud, vnd, vd, d);
+        else
+            vec_mul(vnd, vd, und, ud, d);
+
+        COPY_DIGITS(us, unb, old_und, ud, unb + vnb, nd, d);
+
+#ifndef SC_MAX_NBITS
+        delete [] d;
+#endif
+      }
+#undef COPY_DIGITS
+#undef CONVERT_SM_to_2C_to_SM
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: External functions for DIVISION operators.
+// ----------------------------------------------------------------------------
+
+void
+div_on_help_signed(small_type &us, int unb, int und, sc_digit *ud,
+                   int vnb, int vnd, const sc_digit *vd)
+{
+#define CONVERT_SM_to_2C_to_SM convert_signed_SM_to_2C_to_SM
+#define COPY_DIGITS copy_digits_signed
+    {  // Body of div_on_help
+        int old_und = und;
+
+        und = vec_skip_leading_zeros(und, ud);
+        vnd = vec_skip_leading_zeros(vnd, vd);
+
+        int cmp_res = vec_cmp(und, ud, vnd, vd);
+
+        if (cmp_res < 0) { // u < v => u / v = 0 - case 4
+            us = SC_ZERO;
+            vec_zero(old_und, ud);
+            return;
+        }
+
+        sc_digit vd0 = (*vd);
+
+        if ((cmp_res > 0) && (vnd == 1) && (vd0 == 1)) {
+            us = CONVERT_SM_to_2C_to_SM(us, unb, old_und, ud);
+            return;
+        }
+
+        // One extra digit for d is allocated to simplify vec_div_*().
+        int nd = sc_max(und, vnd) + 1;
+
+#ifdef SC_MAX_NBITS
+        sc_digit d[MAX_NDIGITS + 1];
+#else
+        sc_digit *d = new sc_digit[nd];
+#endif
+
+        vec_zero(nd, d);
+
+        // u = v => u / v = 1 - case 3
+        if (cmp_res == 0)
+            d[0] = 1;
+        else if ((vnd == 1) && (und == 1))
+            d[0] = (*ud) / vd0;
+        else if ((vnd == 1) && (vd0 < HALF_DIGIT_RADIX))
+            vec_div_small(und, ud, vd0, d);
+        else
+            vec_div_large(und, ud, vnd, vd, d);
+
+        COPY_DIGITS(us, unb, old_und, ud, sc_max(unb, vnb), nd - 1, d);
+
+#ifndef SC_MAX_NBITS
+        delete [] d;
+#endif
+    }
+#undef COPY_DIGITS
+#undef CONVERT_SM_to_2C_to_SM
+}
+
+
+void
+div_on_help_unsigned(small_type &us, int unb, int und, sc_digit *ud,
+                     int vnb, int vnd, const sc_digit *vd)
+{
+#define CONVERT_SM_to_2C_to_SM convert_unsigned_SM_to_2C_to_SM
+#define COPY_DIGITS copy_digits_unsigned
+    { // Body of div_on_help
+        int old_und = und;
+
+        und = vec_skip_leading_zeros(und, ud);
+        vnd = vec_skip_leading_zeros(vnd, vd);
+
+        int cmp_res = vec_cmp(und, ud, vnd, vd);
+
+        if (cmp_res < 0) { // u < v => u / v = 0 - case 4
+            us = SC_ZERO;
+            vec_zero(old_und, ud);
+            return;
+        }
+
+        sc_digit vd0 = (*vd);
+
+        if ((cmp_res > 0) && (vnd == 1) && (vd0 == 1))  {
+            us = CONVERT_SM_to_2C_to_SM(us, unb, old_und, ud);
+            return;
+        }
+
+        // One extra digit for d is allocated to simplify vec_div_*().
+        int nd = sc_max(und, vnd) + 1;
+
+#ifdef SC_MAX_NBITS
+        sc_digit d[MAX_NDIGITS + 1];
+#else
+        sc_digit *d = new sc_digit[nd];
+#endif
+
+        vec_zero(nd, d);
+
+        // u = v => u / v = 1 - case 3
+        if (cmp_res == 0)
+            d[0] = 1;
+        else if ((vnd == 1) && (und == 1))
+            d[0] = (*ud) / vd0;
+        else if ((vnd == 1) && (vd0 < HALF_DIGIT_RADIX))
+            vec_div_small(und, ud, vd0, d);
+        else
+            vec_div_large(und, ud, vnd, vd, d);
+
+        COPY_DIGITS(us, unb, old_und, ud, sc_max(unb, vnb), nd - 1, d);
+
+#ifndef SC_MAX_NBITS
+        delete [] d;
+#endif
+      }
+#undef COPY_DIGITS
+#undef CONVERT_SM_to_2C_to_SM
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: External functions for MOD operators.
+// ----------------------------------------------------------------------------
+
+void
+mod_on_help_signed(small_type &us, int unb, int und, sc_digit *ud,
+                   int /* vnb */, int vnd, const sc_digit *vd)
+{
+#define COPY_DIGITS copy_digits_signed
+    { // Body of mod_on_help
+        int old_und = und;
+
+        und = vec_skip_leading_zeros(und, ud);
+        vnd = vec_skip_leading_zeros(vnd, vd);
+
+        int cmp_res = vec_cmp(und, ud, vnd, vd);
+
+        // u < v => u % v = u - case 4
+        if (cmp_res < 0)
+            return;
+
+        // u = v => u % v = 0 - case 3
+        if (cmp_res == 0) {
+            us = SC_ZERO;
+            vec_zero(old_und, ud);
+            return;
+        }
+        // else if u > v - case 5
+
+        sc_digit vd0 = (*vd);
+
+        if ((vnd == 1) && (vd0 == 1)) {
+            us = SC_ZERO;
+            vec_zero(old_und, ud);
+            return;
+        }
+
+        // One extra digit for d is allocated to simplify vec_div_*().
+        int nd = sc_max(und, vnd) + 1;
+
+#ifdef SC_MAX_NBITS
+        sc_digit d[MAX_NDIGITS + 1];
+#else
+        sc_digit *d = new sc_digit[nd];
+#endif
+
+        vec_zero(nd, d);
+
+        if ((vnd == 1) && (und == 1))
+            d[0] = (*ud) % vd0;
+        if ((vnd == 1) && (vd0 < HALF_DIGIT_RADIX))
+            d[0] = vec_rem_small(und, ud, vd0);
+        else
+            vec_rem_large(und, ud, vnd, vd, d);
+
+        us = check_for_zero(us, nd - 1, d);
+
+        if (us == SC_ZERO)
+            vec_zero(old_und, ud);
+        else
+            COPY_DIGITS(us, unb, old_und, ud, sc_min(unb, vnd), nd - 1, d);
+
+#ifndef SC_MAX_NBITS
+        delete [] d;
+#endif
+    }
+#undef COPY_DIGITS
+}
+
+
+void
+mod_on_help_unsigned(small_type &us, int unb, int und, sc_digit *ud,
+                     int /* vnb */, int vnd, const sc_digit *vd)
+{
+#define COPY_DIGITS copy_digits_unsigned
+    { // Body of mod_on_help
+        int old_und = und;
+
+        und = vec_skip_leading_zeros(und, ud);
+        vnd = vec_skip_leading_zeros(vnd, vd);
+
+        int cmp_res = vec_cmp(und, ud, vnd, vd);
+
+        // u < v => u % v = u - case 4
+        if (cmp_res < 0)
+            return;
+
+        // u = v => u % v = 0 - case 3
+        if (cmp_res == 0) {
+            us = SC_ZERO;
+            vec_zero(old_und, ud);
+            return;
+        }
+
+        // else if u > v - case 5
+
+        sc_digit vd0 = (*vd);
+
+        if ((vnd == 1) && (vd0 == 1)) {
+            us = SC_ZERO;
+            vec_zero(old_und, ud);
+            return;
+        }
+
+        // One extra digit for d is allocated to simplify vec_div_*().
+        int nd = sc_max(und, vnd) + 1;
+
+#ifdef SC_MAX_NBITS
+        sc_digit d[MAX_NDIGITS + 1];
+#else
+        sc_digit *d = new sc_digit[nd];
+#endif
+
+        vec_zero(nd, d);
+
+        if ((vnd == 1) && (und == 1))
+            d[0] = (*ud) % vd0;
+        if ((vnd == 1) && (vd0 < HALF_DIGIT_RADIX))
+            d[0] = vec_rem_small(und, ud, vd0);
+        else
+            vec_rem_large(und, ud, vnd, vd, d);
+
+        us = check_for_zero(us, nd - 1, d);
+
+        if (us == SC_ZERO)
+            vec_zero(old_und, ud);
+        else
+            COPY_DIGITS(us, unb, old_und, ud, sc_min(unb, vnd), nd - 1, d);
+
+#ifndef SC_MAX_NBITS
+        delete [] d;
+#endif
+    }
+#undef COPY_DIGITS
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: External functions for AND operators.
+// ----------------------------------------------------------------------------
+
+// Handles the cases 2-5 and returns the result in u.
+void
+and_on_help(small_type us, int /* unb */, int und, sc_digit *ud,
+            small_type vs, int /* vnb */, int vnd, const sc_digit *vd)
+{
+    sc_digit *x = ud;
+    const sc_digit *y = vd;
+    int xnd = und;
+    int ynd = vnd;
+
+    // Truncate y.
+    if (xnd < ynd)
+        ynd = xnd;
+
+    const sc_digit *xend = (x + xnd);
+    const sc_digit *yend = (y + ynd);
+
+    // x is longer than y.
+    small_type s = mul_signs(us, vs);
+
+    if (s > 0) {
+        if (us > 0) { // case 2
+            while (y < yend)
+                (*x++) &= (*y++);
+            while (x < xend)
+                (*x++) = 0;
+        } else { // case 3
+            sc_digit xcarry = 1;
+            sc_digit ycarry = 1;
+            while (y < yend) {
+                xcarry += (~(*x) & DIGIT_MASK);
+                ycarry += (~(*y++) & DIGIT_MASK);
+                (*x++) = (xcarry & ycarry) & DIGIT_MASK;
+                xcarry >>= BITS_PER_DIGIT;
+                ycarry >>= BITS_PER_DIGIT;
+            }
+            while (x < xend) {
+                xcarry += (~(*x) & DIGIT_MASK);
+                ycarry += DIGIT_MASK;
+                (*x++) = (xcarry & ycarry) & DIGIT_MASK;
+                xcarry >>= BITS_PER_DIGIT;
+                ycarry >>= BITS_PER_DIGIT;
+            }
+
+        }
+    } else {
+        if (us > 0) { // case 4
+            sc_digit ycarry = 1;
+            while (y < yend) {
+                ycarry += (~(*y++) & DIGIT_MASK);
+                (*x++) &= ycarry & DIGIT_MASK;
+                ycarry >>= BITS_PER_DIGIT;
+            }
+            while (x < xend) {
+                ycarry += DIGIT_MASK;
+                (*x++) &= ycarry & DIGIT_MASK;
+                ycarry >>= BITS_PER_DIGIT;
+            }
+        } else { // case 5
+            sc_digit xcarry = 1;
+            while (y < yend) {
+                xcarry += (~(*x) & DIGIT_MASK);
+                (*x++) = (xcarry & (*y++)) & DIGIT_MASK;
+                xcarry >>= BITS_PER_DIGIT;
+            }
+            while (x < xend)
+                (*x++) = 0;
+        }
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: External functions for OR operators.
+// ----------------------------------------------------------------------------
+
+// Handles the cases 3-5 and returns the result in u.
+void
+or_on_help(small_type us, int /* unb */, int und, sc_digit *ud,
+           small_type vs, int /* vnb */, int vnd, const sc_digit *vd)
+{
+    sc_digit *x = ud;
+    const sc_digit *y = vd;
+    int xnd = und;
+    int ynd = vnd;
+
+    if (xnd < ynd)
+        ynd = xnd;
+
+    const sc_digit *xend = (x + xnd);
+    const sc_digit *yend = (y + ynd);
+
+    // x is longer than y.
+    small_type s = mul_signs(us, vs);
+
+    if (s > 0) {
+        if (us > 0) { // case 3
+            while (y < yend)
+                (*x++) |= (*y++);
+            // No change for the rest of x.
+        } else { // case 4
+            sc_digit xcarry = 1;
+            sc_digit ycarry = 1;
+            while (y < yend) {
+                xcarry += (~(*x) & DIGIT_MASK);
+                ycarry += (~(*y++) & DIGIT_MASK);
+                (*x++) = (xcarry | ycarry) & DIGIT_MASK;
+                xcarry >>= BITS_PER_DIGIT;
+                ycarry >>= BITS_PER_DIGIT;
+            }
+            while (x < xend) {
+                xcarry += (~(*x) & DIGIT_MASK);
+                ycarry += DIGIT_MASK;
+                (*x++) = (xcarry | ycarry) & DIGIT_MASK;
+                xcarry >>= BITS_PER_DIGIT;
+                ycarry >>= BITS_PER_DIGIT;
+            }
+        }
+    } else {
+        if (us > 0) { // case 5
+            sc_digit ycarry = 1;
+            while (y < yend) {
+                ycarry += (~(*y++) & DIGIT_MASK);
+                (*x) = ((*x) | ycarry) & DIGIT_MASK;
+                x++;
+                ycarry >>= BITS_PER_DIGIT;
+            }
+            while (x < xend) {
+                ycarry += DIGIT_MASK;
+                (*x) = ((*x) | ycarry) & DIGIT_MASK;
+                x++;
+                ycarry >>= BITS_PER_DIGIT;
+            }
+        } else { // case 6
+            sc_digit xcarry = 1;
+            while (y < yend) {
+                xcarry += (~(*x) & DIGIT_MASK);
+                (*x++) = (xcarry | (*y++)) & DIGIT_MASK;
+                xcarry >>= BITS_PER_DIGIT;
+            }
+            while (x < xend) {
+                xcarry += (~(*x) & DIGIT_MASK);
+                (*x++) = xcarry & DIGIT_MASK;
+                xcarry >>= BITS_PER_DIGIT;
+            }
+        }
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: External functions for XOR operators.
+// ----------------------------------------------------------------------------
+
+// Handles the cases 3-5 and returns the result in u.
+void
+xor_on_help(small_type us, int /* unb */, int und, sc_digit *ud,
+            small_type vs, int /* vnb */, int vnd, const sc_digit *vd)
+{
+    sc_digit *x = ud;
+    const sc_digit *y = vd;
+    int xnd = und;
+    int ynd = vnd;
+
+    if (xnd < ynd)
+        ynd = xnd;
+
+    const sc_digit *xend = (x + xnd);
+    const sc_digit *yend = (y + ynd);
+
+    // x is longer than y.
+    small_type s = mul_signs(us, vs);
+
+    if (s > 0) {
+        if (us > 0) { // case 3
+            while (y < yend) {
+                (*x) = ((*x) ^ (*y)) & DIGIT_MASK;
+                x++;
+                y++;
+            }
+            // No change for the rest of x.
+        } else { // case 4
+            sc_digit xcarry = 1;
+            sc_digit ycarry = 1;
+            while (y < yend) {
+                xcarry += (~(*x) & DIGIT_MASK);
+                ycarry += (~(*y++) & DIGIT_MASK);
+                (*x++) = (xcarry ^ ycarry) & DIGIT_MASK;
+                xcarry >>= BITS_PER_DIGIT;
+                ycarry >>= BITS_PER_DIGIT;
+            }
+            while (x < xend) {
+                xcarry += (~(*x) & DIGIT_MASK);
+                ycarry += DIGIT_MASK;
+                (*x++) = (xcarry ^ ycarry) & DIGIT_MASK;
+                xcarry >>= BITS_PER_DIGIT;
+                ycarry >>= BITS_PER_DIGIT;
+            }
+        }
+    } else {
+        if (us > 0) { // case 5
+            sc_digit ycarry = 1;
+            while (y < yend) {
+                ycarry += (~(*y++) & DIGIT_MASK);
+                (*x) = ((*x) ^ ycarry) & DIGIT_MASK;
+                x++;
+                ycarry >>= BITS_PER_DIGIT;
+            }
+            while (x < xend) {
+                ycarry += DIGIT_MASK;
+                (*x) = ((*x) ^ ycarry) & DIGIT_MASK;
+                x++;
+                ycarry >>= BITS_PER_DIGIT;
+            }
+        } else { // case 6
+            sc_digit xcarry = 1;
+            while (y < yend) {
+                xcarry += (~(*x) & DIGIT_MASK);
+                (*x++) = (xcarry ^ (*y++)) & DIGIT_MASK;
+                xcarry >>= BITS_PER_DIGIT;
+            }
+            while (x < xend) {
+                xcarry += (~(*x) & DIGIT_MASK);
+                (*x++) = xcarry & DIGIT_MASK;
+                xcarry >>= BITS_PER_DIGIT;
+            }
+        }
+    }
+}
+
+} // namespace sc_dt
diff --git a/src/systemc/dt/int/sc_nbfriends.inc b/src/systemc/dt/int/sc_nbfriends.inc
new file mode 100644
index 0000000..9161692
--- /dev/null
+++ b/src/systemc/dt/int/sc_nbfriends.inc
@@ -0,0 +1,582 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_nbfriends.inc -- Friend functions for both sc_signed and sc_unsigned
+                      classes. The vec_* functions are called through either
+                      these functions or those in sc_nbexterns.cpp. These
+                      functions perform their work on two inputs u and v, and
+                      return the result object. The functions in
+                      sc_nbexterns.cpp perform their work on one of their
+                      inputs.
+
+                      The functions here try to use faster algorithms in case
+                      the input numbers are small. The bitwise functions (and,
+                      or, and xor) need the 2's complement representations of
+                      their inputs. Instead of complementing their inputs
+                      first and then processing, they complement their inputs
+                      while processing without allocating extra temporary
+                      memory.
+
+  Original Author: Ali Dasdan, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// ----------------------------------------------------------------------------
+//  Naming conventions:
+//  For sc_signed or sc_unsigned number u:
+//    us : u's sign, unb : u's number of bits, 
+//    und : u's number of digits, ud : u's digits array.
+// ----------------------------------------------------------------------------
+
+// ----------------------------------------------------------------------------
+//  SECTION: Friend functions for PLUS operators.
+// ----------------------------------------------------------------------------
+
+// Handles cases 3 and 4 and returns the result.
+CLASS_TYPE
+ADD_HELPER(small_type us, int unb, int und, const sc_digit *ud, 
+           small_type vs, int vnb, int vnd, const sc_digit *vd)
+{
+    und = vec_skip_leading_zeros(und, ud);
+    vnd = vec_skip_leading_zeros(vnd, vd);
+
+    int nb = sc_max(unb, vnb);
+    int nd = sc_max(und, vnd) + 1;
+
+#ifdef SC_MAX_NBITS
+    test_bound(nb);
+    sc_digit d[MAX_NDIGITS];
+#else
+    sc_digit *d = new sc_digit[nd];
+#endif
+    
+    d[nd - 1] = d[nd - 2] = 0;
+
+    // case 3
+    if (us == vs) {
+
+        ++nb;
+
+        if ((und == 1) && (vnd == 1)) {
+            sc_digit carry = (*ud) + (*vd);
+            d[0] = carry & DIGIT_MASK;
+            d[1] = carry >> BITS_PER_DIGIT;
+        } else if (und >= vnd) {
+            vec_add(und, ud, vnd, vd, d);
+        } else {
+            vec_add(vnd, vd, und, ud, d);
+        }
+    } else {
+        // case 4
+        int cmp_res = vec_cmp(und, ud, vnd, vd);
+        
+        if (cmp_res == 0) { // u == v
+#ifndef SC_MAX_NBITS
+            delete[] d;
+#endif
+            return CLASS_TYPE();
+        }
+        
+        if (cmp_res > 0) { // u > v
+            if ((und == 1) && (vnd == 1))
+                d[0] = (*ud) - (*vd);
+            else
+                vec_sub(und, ud, vnd, vd, d);
+        } else { // u < v
+            us = -us;
+            if ((und == 1) && (vnd == 1))
+                d[0] = (*vd) - (*ud);
+            else
+                vec_sub(vnd, vd, und, ud, d);
+        }
+    }
+    return CLASS_TYPE(us, nb, nd, d);
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Friend functions of MULTIPLICATION operators.
+// ----------------------------------------------------------------------------
+
+// Handles the case 4 and returns the result.
+CLASS_TYPE 
+MUL_HELPER(small_type s, int unb, int und,  const sc_digit *ud, 
+           int vnb, int vnd, const sc_digit *vd)
+{
+    und = vec_skip_leading_zeros(und, ud);
+    vnd = vec_skip_leading_zeros(vnd, vd);
+
+    int nb = unb + vnb;
+    int nd = und + vnd;
+    
+#ifdef SC_MAX_NBITS
+    test_bound(nb);
+    sc_digit d[MAX_NDIGITS];
+#else
+    sc_digit *d = new sc_digit[nd];
+#endif
+
+    vec_zero(nd, d);
+        
+    sc_digit ud0 = (*ud);
+    sc_digit vd0 = (*vd);
+
+    if ((vnd == 1) && (vd0 == 1)) {
+        vec_copy(und, d, ud);
+    } else if ((und == 1) && (ud0 == 1)) {
+        vec_copy(vnd, d, vd);
+    } else if ((und == 1) && (vnd == 1) && 
+               (ud0 < HALF_DIGIT_RADIX) && (vd0 < HALF_DIGIT_RADIX)) {
+        d[0] = ud0 * vd0;
+    } else if ((und == 1) && (ud0 < HALF_DIGIT_RADIX)) {
+        vec_mul_small(vnd, vd, ud0, d);
+    } else if ((vnd == 1) && (vd0 < HALF_DIGIT_RADIX)) {
+        vec_mul_small(und, ud, vd0, d);
+    } else if (vnd < und) {
+        vec_mul(und, ud, vnd, vd, d);
+    } else {
+        vec_mul(vnd, vd, und, ud, d);
+    }
+    return CLASS_TYPE(s, nb, nd, d);
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Friend functions for DIVISION operators.
+// ----------------------------------------------------------------------------
+
+// Handles the cases 3-4 and returns the result.
+CLASS_TYPE 
+DIV_HELPER(small_type s, int unb, int und, const sc_digit *ud, 
+           int vnb, int vnd, const sc_digit *vd)
+{
+    und = vec_skip_leading_zeros(und, ud);
+    vnd = vec_skip_leading_zeros(vnd, vd);
+
+    int cmp_res = vec_cmp(und, ud, vnd, vd);
+
+    // u < v => u / v = 0 - case 4
+    if (cmp_res < 0) 
+        return CLASS_TYPE();
+
+    // One extra digit for d is allocated to simplify vec_div_*().
+    int nd = sc_max(und, vnd) + 1;
+
+#ifdef SC_MAX_NBITS
+    sc_digit d[MAX_NDIGITS + 1];
+#else
+    sc_digit *d = new sc_digit[nd];
+#endif
+
+    vec_zero(nd, d);
+    sc_digit vd0 = (*vd);
+
+    // u = v => u / v = 1 - case 3
+    if (cmp_res == 0) {
+        d[0] = 1;
+    // else if u > v - case 5
+    } else if ((vnd == 1) && (vd0 == 1)) {
+        vec_copy(und, d, ud);
+    } else if ((vnd == 1) && (und == 1)) {
+        d[0] = (*ud) / vd0;
+    } else if ((vnd == 1) && (vd0 < HALF_DIGIT_RADIX)) {
+        vec_div_small(und, ud, vd0, d);
+    } else {
+        vec_div_large(und, ud, vnd, vd, d);
+    }
+
+    return CLASS_TYPE(s, sc_max(unb, vnb), nd - 1, d);
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Friend functions for MOD operators.
+// ----------------------------------------------------------------------------
+
+// Handles the cases 3-4 and returns the result.
+CLASS_TYPE 
+MOD_HELPER(small_type us, int unb, int und, const sc_digit *ud, 
+           int vnb, int vnd, const sc_digit *vd)
+{
+    und = vec_skip_leading_zeros(und, ud);
+    vnd = vec_skip_leading_zeros(vnd, vd);
+
+    int cmp_res = vec_cmp(und, ud, vnd, vd);
+    // u = v => u % v = 0 - case 3
+    if (cmp_res == 0) 
+        return CLASS_TYPE();
+
+    sc_digit vd0 = (*vd);
+    if ((cmp_res > 0) && (vnd == 1) && (vd0 == 1))
+        return CLASS_TYPE();
+
+    // One extra digit for d is allocated to simplify vec_div_*().
+    int nd = sc_max(und, vnd) + 1;
+
+#ifdef SC_MAX_NBITS
+    sc_digit d[MAX_NDIGITS + 1];
+#else
+    sc_digit *d = new sc_digit[nd];
+#endif
+
+    vec_zero(nd, d);
+
+    // u < v => u % v = u - case 4
+    if (cmp_res < 0) {
+        vec_copy(und, d, ud);
+    // else if u > v - case 5
+    } else if ((vnd == 1) && (und == 1)) {
+        d[0] = (*ud) % vd0;
+    } else if ((vnd == 1) && (vd0 < HALF_DIGIT_RADIX)) {
+        d[0] = vec_rem_small(und, ud, vd0);
+    } else {
+        vec_rem_large(und, ud, vnd, vd, d);
+    }
+
+    us = check_for_zero(us, nd - 1, d);
+
+    if (us == SC_ZERO) {
+#ifndef SC_MAX_NBITS
+        delete[] d;
+#endif
+        return CLASS_TYPE();
+    } else {
+        return CLASS_TYPE(us, sc_min(unb, vnb), nd - 1, d);
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Friend functions for AND operators.
+// ----------------------------------------------------------------------------
+
+// Handles the cases 2-5 and returns the result.
+CLASS_TYPE 
+AND_HELPER(small_type us, int unb, int und, const sc_digit *ud, 
+           small_type vs, int vnb, int vnd, const sc_digit *vd)
+{
+    int nb = sc_max(unb, vnb);
+    int nd = sc_max(und, vnd);
+
+#ifdef SC_MAX_NBITS
+    sc_digit dbegin[MAX_NDIGITS];
+#else
+    sc_digit *dbegin = new sc_digit[nd];
+#endif
+
+    sc_digit *d = dbegin;
+
+    const sc_digit *x;
+    const sc_digit *y;
+    int xnd;
+    int ynd;
+    small_type xs;
+    small_type ys;
+
+    if (und >= vnd) {
+        x = ud;
+        y = vd;
+        xnd = und;
+        ynd = vnd;
+        xs = us;
+        ys = vs;
+    } else {
+        y = ud;
+        x = vd;
+        ynd = und;
+        xnd = vnd;
+        ys = us;
+        xs = vs;
+    }
+
+    const sc_digit *xend = (x + xnd);
+    const sc_digit *yend = (y + ynd);
+
+    // x is longer than y.
+    small_type s = mul_signs(xs, ys);
+    if (s > 0) {
+        if (xs > 0) { // case 2
+            while (y < yend)
+                (*d++) = (*x++) & (*y++);
+            while (x++ < xend) 
+                (*d++) = 0;
+        } else { // case 3
+            sc_digit xcarry = 1;
+            sc_digit ycarry = 1;
+            while (y < yend) {
+                xcarry += (~(*x++) & DIGIT_MASK);
+                ycarry += (~(*y++) & DIGIT_MASK);
+                (*d++) = (xcarry & ycarry) & DIGIT_MASK;
+                xcarry >>= BITS_PER_DIGIT;
+                ycarry >>= BITS_PER_DIGIT;
+            }
+            while (x < xend) {
+                xcarry += (~(*x++) & DIGIT_MASK);
+                ycarry += DIGIT_MASK;
+                (*d++) = (xcarry & ycarry) & DIGIT_MASK;
+                xcarry >>= BITS_PER_DIGIT;
+                ycarry >>= BITS_PER_DIGIT;
+            }
+        }
+    } else {
+        if (xs > 0) { // case 4
+            sc_digit ycarry = 1;
+            while (y < yend) {
+                ycarry += (~(*y++) & DIGIT_MASK);
+                (*d++) = ((*x++) & ycarry) & DIGIT_MASK;
+                ycarry >>= BITS_PER_DIGIT;
+            }
+            while (x < xend) {
+                ycarry += DIGIT_MASK;
+                (*d++) = ((*x++) & ycarry) & DIGIT_MASK;
+                ycarry >>= BITS_PER_DIGIT;
+            }
+        } else { // case 5
+            sc_digit xcarry = 1;
+            while (y < yend) {
+                xcarry += (~(*x++) & DIGIT_MASK);
+                (*d++) = (xcarry & (*y++)) & DIGIT_MASK;
+                xcarry >>= BITS_PER_DIGIT;
+            }
+            while (x++ < xend)
+                (*d++) = 0;
+        }
+    }
+    s = convert_signed_2C_to_SM(nb, nd, dbegin);
+    return CLASS_TYPE(s, nb, nd, dbegin);    
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Friend functions for OR operators.
+// ----------------------------------------------------------------------------
+
+// Handles the cases 3-5 and returns the result.
+CLASS_TYPE 
+OR_HELPER(small_type us, int unb, int und, const sc_digit *ud, 
+          small_type vs, int vnb, int vnd, const sc_digit *vd)
+{
+    int nb = sc_max(unb, vnb);
+    int nd = sc_max(und, vnd);
+
+#ifdef SC_MAX_NBITS
+    sc_digit dbegin[MAX_NDIGITS];
+#else
+    sc_digit *dbegin = new sc_digit[nd];
+#endif
+    sc_digit *d = dbegin;
+    const sc_digit *x;
+    const sc_digit *y;
+    int xnd;
+    int ynd;
+    small_type xs;
+    small_type ys;
+
+    if (und >= vnd) {
+        x = ud;
+        y = vd;
+        xnd = und;
+        ynd = vnd;
+        xs = us;
+        ys = vs;
+    } else {
+        y = ud;
+        x = vd;
+        ynd = und;
+        xnd = vnd;
+        ys = us;
+        xs = vs;
+    }
+
+    const sc_digit *xend = (x + xnd);
+    const sc_digit *yend = (y + ynd);
+
+    // x is longer than y.
+    small_type s = mul_signs(xs, ys);
+    if (s > 0) {
+        if (xs > 0) { // case 3
+            while (y < yend)
+                (*d++) = (*x++) | (*y++);
+            while (x < xend)
+                (*d++) = (*x++);
+        } else { // case 4
+            sc_digit xcarry = 1;
+            sc_digit ycarry = 1;
+            while (y < yend) {
+                xcarry += (~(*x++) & DIGIT_MASK);
+                ycarry += (~(*y++) & DIGIT_MASK);
+                (*d++) = (xcarry | ycarry) & DIGIT_MASK;
+                xcarry >>= BITS_PER_DIGIT;
+                ycarry >>= BITS_PER_DIGIT;
+            }
+            while (x < xend) {
+                xcarry += (~(*x++) & DIGIT_MASK);
+                ycarry += DIGIT_MASK;
+                (*d++) = (xcarry | ycarry) & DIGIT_MASK;
+                xcarry >>= BITS_PER_DIGIT;
+                ycarry >>= BITS_PER_DIGIT;
+            }
+        }
+    } else {
+        if (xs > 0) { // case 5
+            sc_digit ycarry = 1;
+            while (y < yend) {
+                ycarry += (~(*y++) & DIGIT_MASK);
+                (*d++) = ((*x++) | ycarry) & DIGIT_MASK;
+                ycarry >>= BITS_PER_DIGIT;
+            }
+            while (x < xend) {
+                ycarry += DIGIT_MASK;
+                (*d++) = ((*x++) | ycarry) & DIGIT_MASK;
+                ycarry >>= BITS_PER_DIGIT;
+            }
+        } else { // case 6
+            sc_digit xcarry = 1;
+            while (y < yend) {
+                xcarry += (~(*x++) & DIGIT_MASK);
+                (*d++) = (xcarry | (*y++)) & DIGIT_MASK;
+                xcarry >>= BITS_PER_DIGIT;
+            }
+            while (x < xend) {
+                xcarry += (~(*x++) & DIGIT_MASK);
+                (*d++) = xcarry & DIGIT_MASK;
+                xcarry >>= BITS_PER_DIGIT;
+            }
+        }
+    }
+    s = convert_signed_2C_to_SM(nb, nd, dbegin);
+    return CLASS_TYPE(s, nb, nd, dbegin);
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Friend functions for XOR operators.
+// ----------------------------------------------------------------------------
+
+// Handles the cases 3-5 and returns the result.
+CLASS_TYPE 
+XOR_HELPER(small_type us, int unb, int und, const sc_digit *ud, 
+           small_type vs, int vnb, int vnd, const sc_digit *vd)
+{
+    int nb = sc_max(unb, vnb);
+    int nd = sc_max(und, vnd);
+
+#ifdef SC_MAX_NBITS
+    sc_digit dbegin[MAX_NDIGITS];
+#else
+    sc_digit *dbegin = new sc_digit[nd];
+#endif
+
+    sc_digit *d = dbegin;
+
+    const sc_digit *x;
+    const sc_digit *y;
+    int xnd;
+    int ynd;
+    small_type xs;
+    small_type ys;
+
+    if (und >= vnd) {
+        x = ud;
+        y = vd;
+        xnd = und;
+        ynd = vnd;
+        xs = us;
+        ys = vs;
+    } else {
+        y = ud;
+        x = vd;
+        ynd = und;
+        xnd = vnd;
+        ys = us;
+        xs = vs;
+    }
+
+    const sc_digit *xend = (x + xnd);
+    const sc_digit *yend = (y + ynd);
+
+    // x is longer than y.
+    small_type s = mul_signs(xs, ys);
+    if (s > 0) {
+        if (xs > 0) { // case 3
+            while (y < yend)
+                (*d++) = ((*x++) ^ (*y++)) & DIGIT_MASK;
+            while (x < xend)
+                (*d++) = (*x++);
+        } else { // case 4
+            sc_digit xcarry = 1;
+            sc_digit ycarry = 1;
+            while (y < yend) {
+                xcarry += (~(*x++) & DIGIT_MASK);
+                ycarry += (~(*y++) & DIGIT_MASK);
+                (*d++) = (xcarry ^ ycarry) & DIGIT_MASK;
+                xcarry >>= BITS_PER_DIGIT;
+                ycarry >>= BITS_PER_DIGIT;
+            }
+            while (x < xend) {
+                xcarry += (~(*x++) & DIGIT_MASK);
+                ycarry += DIGIT_MASK;
+                (*d++) = (xcarry ^ ycarry) & DIGIT_MASK;
+                xcarry >>= BITS_PER_DIGIT;
+                ycarry >>= BITS_PER_DIGIT;
+            }
+        }
+    } else {
+        if (xs > 0) { // case 5
+            sc_digit ycarry = 1;
+            while (y < yend) {
+                ycarry += (~(*y++) & DIGIT_MASK);
+                (*d++) = ((*x++) ^ ycarry) & DIGIT_MASK;
+                ycarry >>= BITS_PER_DIGIT;
+            }
+            while (x < xend) {
+                ycarry += DIGIT_MASK;
+                (*d++) = ((*x++) ^ ycarry) & DIGIT_MASK;
+                ycarry >>= BITS_PER_DIGIT;
+            }
+        } else { // case 6
+            sc_digit xcarry = 1;
+            while (y < yend) {
+                xcarry += (~(*x++) & DIGIT_MASK);
+                (*d++) = (xcarry ^ (*y++)) & DIGIT_MASK;
+                xcarry >>= BITS_PER_DIGIT;
+            }
+            while (x < xend) {
+                xcarry += (~(*x++) & DIGIT_MASK);
+                (*d++) = xcarry & DIGIT_MASK;
+                xcarry >>= BITS_PER_DIGIT;
+            }
+        }
+    }
+    s = convert_signed_2C_to_SM(nb, nd, dbegin);
+    return CLASS_TYPE(s, nb, nd, dbegin);
+}
diff --git a/src/systemc/dt/int/sc_nbutils.cc b/src/systemc/dt/int/sc_nbutils.cc
new file mode 100644
index 0000000..df7cc55
--- /dev/null
+++ b/src/systemc/dt/int/sc_nbutils.cc
@@ -0,0 +1,1749 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_nbutils.cpp -- External and friend functions for both sc_signed and
+                    sc_unsigned classes.
+
+  Original Author: Ali Dasdan, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: sc_nbutils.cpp,v $
+// Revision 1.4  2011/08/24 22:05:46  acg
+//  Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.3  2011/02/18 20:19:15  acg
+//  Andy Goodrich: updating Copyright notice.
+//
+// Revision 1.2  2007/11/04 21:26:40  acg
+//  Andy Goodrich: added a buffer to the allocation of the q array to address
+//  an issue with references outside the array by 1 byte detected by valgrind.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:49:32  acg
+// Added $Log command so that CVS check in comments are reproduced in the
+// source.
+//
+
+#include <cctype>
+#include <cstdio>
+#include <cstring>
+#include <sstream>
+
+#include "systemc/ext/dt/int/sc_nbutils.hh"
+#include "systemc/ext/utils/functions.hh"
+
+namespace sc_dt
+{
+
+// only used within vec_from_str (non-standard, deprecated)
+static inline void
+is_valid_base(sc_numrep base)
+{
+    switch (base) {
+      case SC_NOBASE: case SC_BIN:
+      case SC_OCT: case SC_DEC:
+      case SC_HEX:
+        break;
+      case SC_BIN_US: case SC_BIN_SM:
+      case SC_OCT_US: case SC_OCT_SM:
+      case SC_HEX_US: case SC_HEX_SM:
+      case SC_CSD:
+        SC_REPORT_ERROR("not implemented",
+                        "is_valid_base( sc_numrep base ) : "
+                        "bases SC_CSD, or ending in _US and _SM are "
+                        "not supported");
+        break;
+      default:
+        std::stringstream msg;
+        msg << "is_valid_base( sc_numrep base ) : base = " << base <<
+               " is not valid";
+        SC_REPORT_ERROR("value is not valid", msg.str().c_str() );
+    }
+}
+
+// ----------------------------------------------------------------------------
+//  ENUM : sc_numrep
+//
+//  Enumeration of number representations for character string conversion.
+// ----------------------------------------------------------------------------
+
+const std::string
+to_string(sc_numrep numrep)
+{
+    switch (numrep) {
+#define CASE_ENUM2STR(Value) case Value: return #Value
+
+      CASE_ENUM2STR(SC_DEC);
+
+      CASE_ENUM2STR(SC_BIN);
+      CASE_ENUM2STR(SC_BIN_US);
+      CASE_ENUM2STR(SC_BIN_SM);
+
+      CASE_ENUM2STR(SC_OCT);
+      CASE_ENUM2STR(SC_OCT_US);
+      CASE_ENUM2STR(SC_OCT_SM);
+
+      CASE_ENUM2STR(SC_HEX);
+      CASE_ENUM2STR(SC_HEX_US);
+      CASE_ENUM2STR(SC_HEX_SM);
+
+      CASE_ENUM2STR(SC_CSD);
+
+#undef CASE_ENUM2STR
+
+      default:
+        return "unknown";
+    }
+}
+
+// ----------------------------------------------------------------------------
+//  SECTION: General utility functions.
+// ----------------------------------------------------------------------------
+
+// Return the number of characters to advance the source of c.  This
+// function implements one move of the FSM to parse the following
+// regular expressions. Error checking is done in the caller.
+
+small_type
+fsm_move(char c, small_type &b, small_type &s, small_type &state)
+{
+    // Possible regular expressions (REs):
+    // Let N = any digit depending on the base.
+    //    1. [0|1|..|9]N*
+    //    2. [+|-][0|1|..|9]N*
+    //    3. 0[b|B|d|D|o|O|x|X][0|1|..|F]N*
+    //    4. [+|-]?0[b|B|d|D|o|O|x|X][0|1|..|F]N*
+    //
+    // The finite state machine (FMS) to parse these regular expressions
+    // has 4 states, 0 to 3. 0 is the initial state and 3 is the final
+    // state.
+    //
+    // Default sign = SC_POS, default base = NB_DEFAULT_BASE.
+
+    switch (state) {
+      case 0: // The initial state.
+        switch (c) {
+          case '0': s = SC_POS; state = 1; return 0; // RE 1 or 3
+          case '+': s = SC_POS; state = 2; return 1; // RE 2
+          case '-': s = SC_NEG; state = 2; return 1; // RE 2
+          default:
+            s = SC_POS; b = NB_DEFAULT_BASE; state = 3; return 0; // RE 1
+        }
+        // break; //unreachable code
+      case 1: // 0...
+        switch (c) {
+          case 'x': case 'X': b = SC_HEX; state = 3; return 2; // RE 3 or 4
+          case 'd': case 'D': b = SC_DEC; state = 3; return 2; // RE 3 or 4
+          case 'o': case 'O': b = SC_OCT; state = 3; return 2; // RE 3 or 4
+          case 'b': case 'B': b = SC_BIN; state = 3; return 2; // RE 3 or 4
+          default: b = NB_DEFAULT_BASE; state = 3; return 0; // RE 1
+        }
+        // break; //unreachable code
+      case 2: // +... or -...
+        switch (c) {
+          case '0': state = 1; return 0; // RE 2 or 4
+          default: b = NB_DEFAULT_BASE; state = 3; return 0; // RE 2
+        }
+        // break; //unreachable code
+      case 3: // The final state.
+        break;
+      default:
+        // Any other state is not possible.
+        sc_assert((0 <= state) && (state <= 3));
+    } // switch
+    return 0;
+}
+
+
+// Get base b and sign s of the number in the char string v. Return a
+// pointer to the first char after the point where b and s are
+// determined or where the end of v is reached. The input string v has
+// to be null terminated.
+const char *
+get_base_and_sign(const char *v, small_type &b, small_type &s)
+{
+#ifdef DEBUG_SYSTEMC
+    sc_assert(v != NULL);
+#endif
+    const small_type STATE_START = 0;
+    const small_type STATE_FINISH = 3;
+
+    // Default sign = SC_POS, default base = 10.
+    s = SC_POS;
+    b = NB_DEFAULT_BASE;
+
+    small_type state = STATE_START;
+    small_type nskip = 0; // Skip that many chars.
+    const char *u = v;
+
+    while (*u) {
+        if (isspace(*u)) { // Skip white space.
+            ++u;
+        } else {
+            nskip += fsm_move(*u, b, s, state);
+            if (state == STATE_FINISH)
+              break;
+            else
+              ++u;
+        }
+    }
+
+    // Test to see if the above loop executed more than it should
+    // have. The max number of skipped chars is equal to the length of
+    // the longest format specifier, e.g., "-0x".
+    sc_assert(nskip <= 3);
+
+    v += nskip;
+
+    // Handles empty strings or strings without any digits after the
+    // base or base and sign specifier.
+    if (*v == '\0') {
+        static const char msg[] =
+            "get_base_and_sign( const char* v, small_type&, small_type& ) : "
+            "v = \"\" is not valid";
+        SC_REPORT_ERROR("conversion failed", msg);
+    }
+    return v;
+}
+
+//-----------------------------------------------------------------------------
+//"parse_binary_bits"
+//
+// This function parses the supplied string into the supplied vector as a
+// right justified bit value.
+//    src_p  -> character string representing the bits to be parsed.
+//    dst_n  =  number of words in data_p and ctrl_p.
+//    data_p -> words w/BITS_PER_DIGIT bits to receive the value's data bits.
+//    ctrl_p -> words w/BITS_PER_DIGIT bits to receive the value's control
+//              bits, or zero.
+// Result is true if value was non-zero.
+//-----------------------------------------------------------------------------
+void
+parse_binary_bits(const char *src_p, int dst_n,
+                  sc_digit *data_p, sc_digit *ctrl_p)
+{
+    int bit_i; // Number of bit now processing.
+    sc_digit ctrl; // Control word now assembling.
+    sc_digit data; // Data word now assembling.
+    int delta_n; // src_n - dst_n*BITS_PER_DIGIT.
+    int src_i; // Index in src_p now accessing (left to right).
+    int src_n; // Length of source that is left in bits.
+    int word_i; // Bit within word now accessing (left to right).
+
+    // MAKE SURE WE HAVE A STRING TO PARSE:
+    if (src_p == 0) {
+        SC_REPORT_ERROR("conversion failed",
+                        "character string is zero");
+        return;
+    }
+    if (*src_p == 0) {
+        SC_REPORT_ERROR("conversion failed",
+                        "character string is empty");
+        return;
+    }
+
+
+    // INDEX INTO THE SOURCE TO A DEPTH THAT WILL ACCOMODATE OUR SIZE:
+    //
+    // If the source is smaller than our value initialize our value to zero.
+
+    src_n = strlen(src_p);
+    delta_n = src_n - (dst_n*BITS_PER_DIGIT);
+    if (delta_n > 0) {
+        src_p = &src_p[delta_n];
+        src_n -= delta_n;
+    } else {
+        for (word_i = 0; word_i < dst_n; word_i++)
+            data_p[word_i] = 0;
+        if (ctrl_p)
+            for (word_i = 0; word_i < dst_n; word_i++)
+                ctrl_p[word_i] = 0;
+    }
+
+    // LOOP OVER THE SOURCE ASSEMBLING WORDS AND PLACING THEM IN OUR VALUE:
+    //
+    // We stride right to left through the source in BITS_PER_DIGIT chunks.
+    // Each of those chunks is processed from left to right a bit at a time.
+    // We process the high order word specially, since there are less bits.
+    src_n = src_n - BITS_PER_DIGIT;
+    for (word_i=0; word_i < dst_n; word_i++) {
+        src_i = src_n;
+
+        // PARTIAL LAST WORD TO ASSEMBLE:
+        if (src_i < 0) {
+            src_n += BITS_PER_DIGIT;
+            data = 0;
+            ctrl = 0;
+            for (src_i = 0; src_i < src_n; src_i++) {
+                ctrl = ctrl << 1;
+                data = data << 1;
+                switch (src_p[src_i]) {
+                  case 'X':
+                  case 'x': ctrl = ctrl | 1; data = data | 1; break;
+                  case '1': data = data | 1; break;
+                  case 'Z':
+                  case 'z': ctrl = ctrl | 1; break;
+                  case '0': break;
+                  default:
+                    {
+                        std::stringstream msg;
+                        msg << "character string '" << src_p <<
+                               "' is not valid";
+                        SC_REPORT_ERROR("conversion failed",
+                                        msg.str().c_str());
+                        return;
+                    }
+                    break;
+                }
+            }
+            if (ctrl_p)
+                ctrl_p[word_i] = ctrl;
+            data_p[word_i] = data;
+            break;
+        }
+
+        // FULL WORD TO BE ASSEMBLED:
+        ctrl = 0;
+        data = 0;
+        for (bit_i = 0; bit_i < BITS_PER_DIGIT; bit_i++) {
+            ctrl = ctrl << 1;
+            data = data << 1;
+            switch (src_p[src_i++]) {
+              case 'X':
+              case 'x': ctrl = ctrl | 1; data = data | 1; break;
+              case '1': data = data | 1; break;
+              case 'Z':
+              case 'z': ctrl = ctrl | 1; break;
+              case '0': break;
+              default:
+                {
+                    std::stringstream msg;
+                    msg << "character string '" << src_p <<
+                           "' is not valid";
+                    SC_REPORT_ERROR("conversion failed",
+                                    msg.str().c_str());
+                    return;
+                }
+                break;
+            }
+        }
+        if (ctrl_p)
+            ctrl_p[word_i] = ctrl;
+        data_p[word_i] = data;
+        src_n = src_n - BITS_PER_DIGIT;
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+//"parse_hex_bits"
+//
+// This function parses the supplied string into the supplied vector as a
+// right justified bit value.
+//    src_p  -> character string representing the bits to be parsed.
+//    dst_n  =  number of words in data_p and ctrl_p.
+//    data_p -> words w/32 bits to receive the value's data bits.
+//    ctrl_p -> words w/32 bits to receive the value's control bits,
+//              or zero.
+// Result is true if value was non-zero.
+//-----------------------------------------------------------------------------
+void
+parse_hex_bits(const char *src_p, int dst_n,
+               sc_digit *data_p, sc_digit *ctrl_p)
+{
+    sc_digit ctrl; // Control word now assembling.
+    sc_digit data; // Data word now assembling.
+    int delta_n; // src_n - dst_n*BITS_PER_DIGIT.
+    int digit_i; // Number of digit now processing.
+    int src_i; // Index in src_p now accessing (left to right).
+    int src_n; // Length of source that is left in bits.
+    int word_i; // Bit within word now accessing (left to right).
+
+    // MAKE SURE WE HAVE A STRING TO PARSE:
+    if (src_p == 0) {
+        SC_REPORT_ERROR("conversion failed",
+                        "character string is zero");
+        return;
+    }
+    if (*src_p == 0) {
+        SC_REPORT_ERROR("conversion failed",
+                        "character string is empty");
+        return;
+    }
+
+    // INDEX INTO THE SOURCE TO A DEPTH THAT WILL ACCOMODATE OUR SIZE:
+    //
+    // If the source is smaller than our value initialize our value to zero.
+    src_n = strlen(src_p);
+    delta_n = src_n - (dst_n*8);
+    if (delta_n > 0) {
+        src_p = &src_p[delta_n];
+        src_n -= delta_n;
+    } else {
+        for (word_i = 0; word_i < dst_n; word_i++)
+            data_p[word_i] = 0;
+        if (ctrl_p)
+            for (word_i = 0; word_i < dst_n; word_i++)
+                ctrl_p[word_i] = 0;
+    }
+
+    // LOOP OVER THE SOURCE ASSEMBLING WORDS AND PLACING THEM IN OUR VALUE:
+    //
+    // We stride right to left through the source in BITS_PER_DIGIT chunks.
+    // Each of those chunks is processed from left to right a bit at a time.
+    // We process the high order word specially, since there are less bits.
+    src_n = src_n - 8;
+    for (word_i = 0; word_i < dst_n; word_i++) {
+        src_i = src_n;
+
+        // PARTIAL LAST WORD TO ASSEMBLE:
+        if (src_i < 0) {
+            src_n += 8;
+            data = 0;
+            ctrl = 0;
+            for (src_i = 0; src_i < src_n; src_i++) {
+                ctrl = ctrl << 4;
+                data = data << 4;
+                switch (src_p[src_i]) {
+                  case 'X':
+                  case 'x': ctrl = ctrl | 15; data = data | 15; break;
+                  case 'F':
+                  case 'f': data = data | 15; break;
+                  case 'E':
+                  case 'e': data = data | 14; break;
+                  case 'D':
+                  case 'd': data = data | 13; break;
+                  case 'C':
+                  case 'c': data = data | 12; break;
+                  case 'B':
+                  case 'b': data = data | 11; break;
+                  case 'A':
+                  case 'a': data = data | 10; break;
+                  case '9': data = data |  9; break;
+                  case '8': data = data |  8; break;
+                  case '7': data = data |  7; break;
+                  case '6': data = data |  6; break;
+                  case '5': data = data |  5; break;
+                  case '4': data = data |  4; break;
+                  case '3': data = data |  3; break;
+                  case '2': data = data |  2; break;
+                  case '1': data = data |  1; break;
+                  case '0': break;
+                  case 'Z':
+                  case 'z': ctrl = ctrl | 15; break;
+                  default:
+                    {
+                        std::stringstream msg;
+                        msg << "character string '" << src_p <<
+                               "' is not valid";
+                        SC_REPORT_ERROR("conversion failed",
+                                        msg.str().c_str());
+                        return;
+                    }
+                    break;
+                }
+            }
+            if (ctrl_p)
+                ctrl_p[word_i] = ctrl;
+            data_p[word_i] = data;
+            break;
+        }
+
+        // FULL WORD TO BE ASSEMBLED:
+        ctrl = 0;
+        data = 0;
+        for (digit_i = 0; digit_i < 8; digit_i++) {
+            ctrl = ctrl << 4;
+            data = data << 4;
+            switch (src_p[src_i++]) {
+              case 'X':
+              case 'x': ctrl = ctrl | 15; data = data | 15; break;
+              case 'F':
+              case 'f': data = data | 15; break;
+              case 'E':
+              case 'e': data = data | 14; break;
+              case 'D':
+              case 'd': data = data | 13; break;
+              case 'C':
+              case 'c': data = data | 12; break;
+              case 'B':
+              case 'b': data = data | 11; break;
+              case 'A':
+              case 'a': data = data | 10; break;
+              case '9': data = data |  9; break;
+              case '8': data = data |  8; break;
+              case '7': data = data |  7; break;
+              case '6': data = data |  6; break;
+              case '5': data = data |  5; break;
+              case '4': data = data |  4; break;
+              case '3': data = data |  3; break;
+              case '2': data = data |  2; break;
+              case '1': data = data |  1; break;
+              case '0': break;
+              case 'Z':
+              case 'z': ctrl = ctrl | 15; break;
+              default:
+                {
+                    std::stringstream msg;
+                    msg << "character string '" << src_p << "' is not valid";
+                    SC_REPORT_ERROR("conversion failed",
+                                    msg.str().c_str() );
+                    return;
+                }
+                break;
+            }
+        }
+        if (ctrl_p)
+            ctrl_p[word_i] = ctrl;
+        data_p[word_i] = data;
+        src_n = src_n - BITS_PER_DIGIT;
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Utility functions involving unsigned vectors.
+// ----------------------------------------------------------------------------
+
+// Read u from a null terminated char string v. Note that operator>>
+// in sc_nbcommon.cpp is similar to this function.
+small_type
+vec_from_str(int unb, int und, sc_digit *u, const char *v, sc_numrep base)
+{
+
+#ifdef DEBUG_SYSTEMC
+    sc_assert((unb > 0) && (und > 0) && (u != NULL));
+    sc_assert(v != NULL);
+#endif
+    is_valid_base(base);
+
+    small_type b, s; // base and sign.
+
+    v = get_base_and_sign(v, b, s);
+
+    if (base != SC_NOBASE) {
+        if (b == NB_DEFAULT_BASE) {
+            b = base;
+        } else {
+            std::stringstream msg;
+            msg << "vec_from_str( int, int, sc_digit*, const char*, " <<
+                   "sc_numrep base ) : base = " << base <<
+                   " does not match the default base";
+            SC_REPORT_ERROR("conversion failed",
+                            msg.str().c_str());
+            return 0;
+        }
+    }
+
+    vec_zero(und, u);
+
+    char c;
+    for (; (c = *v); ++v) {
+        if (isalnum(c)) {
+            small_type val;  // Numeric value of a char.
+
+            if (isalpha(c)) // Hex digit.
+                val = toupper(c) - 'A' + 10;
+            else
+                val = c - '0';
+
+            if (val >= b) {
+                std::stringstream msg;
+                msg << "vec_from_str( int, int, sc_digit*, const char*, " <<
+                       "sc_numrep base ) : '" << *v << "' is not a valid " <<
+                       "digit in base " << b;
+                SC_REPORT_ERROR("conversion failed",
+                                msg.str().c_str());
+                return 0;
+            }
+
+            // digit = digit * b + val;
+            vec_mul_small_on(und, u, b);
+
+            if (val)
+                vec_add_small_on(und, u, val);
+        } else {
+            std::stringstream msg;
+            msg << "vec_from_str( int, int, sc_digit*, const char*, " <<
+                   "sc_numrep base ) : '" << *v << "' is not a valid " <<
+                   "digit in base " << b;
+            SC_REPORT_ERROR("conversion failed",
+                            msg.str().c_str());
+            return 0;
+        }
+    }
+
+    return convert_signed_SM_to_2C_to_SM(s, unb, und, u);
+}
+
+
+// All vec_ functions assume that the vector to hold the result,
+// called w, has sufficient length to hold the result. For efficiency
+// reasons, we do not test whether or not we are out of bounds.
+
+// Compute w = u + v, where w, u, and v are vectors.
+// - ulen >= vlen
+// - wlen >= sc_max(ulen, vlen) + 1
+void
+vec_add(int ulen, const sc_digit *u, int vlen, const sc_digit *v, sc_digit *w)
+{
+#ifdef DEBUG_SYSTEMC
+    sc_assert((ulen > 0) && (u != NULL));
+    sc_assert((vlen > 0) && (v != NULL));
+    sc_assert(w != NULL);
+    sc_assert(ulen >= vlen);
+#endif
+
+    const sc_digit *uend = (u + ulen);
+    const sc_digit *vend = (v + vlen);
+
+    sc_digit carry = 0; // Also used as sum to save space.
+
+    // Add along the shorter v.
+    while (v < vend) {
+        carry += (*u++) + (*v++);
+        (*w++) = carry & DIGIT_MASK;
+        carry >>= BITS_PER_DIGIT;
+    }
+
+    // Propagate the carry.
+    while (carry && (u < uend)) {
+        carry = (*u++) + 1;
+        (*w++) = carry & DIGIT_MASK;
+        carry >>= BITS_PER_DIGIT;
+    }
+
+    // Copy the rest of u to the result.
+    while (u < uend)
+        (*w++) = (*u++);
+
+    // Propagate the carry if it is still 1.
+    if (carry)
+        (*w) = 1;
+}
+
+
+// Compute u += v, where u and v are vectors.
+// - ulen >= vlen
+void
+vec_add_on(int ulen, sc_digit *ubegin, int vlen, const sc_digit *v)
+{
+#ifdef DEBUG_SYSTEMC
+    sc_assert((ulen > 0) && (ubegin != NULL));
+    sc_assert((vlen > 0) && (v != NULL));
+    sc_assert(ulen >= vlen);
+#endif
+
+    sc_digit *u = ubegin;
+    const sc_digit *uend = (u + ulen);
+    const sc_digit *vend = (v + vlen);
+
+    sc_digit carry = 0; // Also used as sum to save space.
+
+    // Add along the shorter v.
+    while (v < vend) {
+        carry += (*u) + (*v++);
+        (*u++) = carry & DIGIT_MASK;
+        carry >>= BITS_PER_DIGIT;
+    }
+
+    // Propagate the carry.
+    while (carry && (u < uend)) {
+        carry = (*u) + 1;
+        (*u++) = carry & DIGIT_MASK;
+        carry >>= BITS_PER_DIGIT;
+    }
+
+#ifdef   DEBUG_SYSTEMC
+    if (carry != 0) {
+        SC_REPORT_WARNING(sc_core::SC_ID_WITHOUT_MESSAGE_,
+                          "vec_add_on( int, sc_digit*, int, const "
+                          "sc_digit* ) : "
+                          "result of addition is wrapped around");
+    }
+#endif
+}
+
+
+// Compute u += v, where u and v are vectors.
+// - ulen < vlen
+void
+vec_add_on2(int ulen, sc_digit *ubegin, int,
+#ifdef DEBUG_SYSTEMC
+            vlen,
+#endif
+            const sc_digit *v)
+{
+#ifdef DEBUG_SYSTEMC
+    sc_assert((ulen > 0) && (ubegin != NULL));
+    sc_assert((vlen > 0) && (v != NULL));
+    sc_assert(ulen < vlen);
+#endif
+
+    sc_digit *u = ubegin;
+    const sc_digit *uend = (u + ulen);
+
+    sc_digit carry = 0; // Also used as sum to save space.
+
+    // Add along the shorter u.
+    while (u < uend) {
+        carry += (*u) + (*v++);
+        (*u++) = carry & DIGIT_MASK;
+        carry >>= BITS_PER_DIGIT;
+    }
+
+#ifdef   DEBUG_SYSTEMC
+    if (carry != 0) {
+        SC_REPORT_WARNING(sc_core::SC_ID_WITHOUT_MESSAGE_,
+                          "vec_add_on2( int, sc_digit*, int, const "
+                          "sc_digit* ) : "
+                          "result of addition is wrapped around");
+    }
+#endif
+}
+
+
+// Compute w = u + v, where w and u are vectors, and v is a scalar.
+void
+vec_add_small(int ulen, const sc_digit *u, sc_digit v, sc_digit *w)
+{
+#ifdef DEBUG_SYSTEMC
+    sc_assert((ulen > 0) && (u != NULL));
+    sc_assert(w != NULL);
+#endif
+
+    const sc_digit *uend = (u + ulen);
+
+    // Add along the shorter v.
+    sc_digit carry = (*u++) + v;
+    (*w++) = carry & DIGIT_MASK;
+    carry >>= BITS_PER_DIGIT;
+
+    // Propagate the carry.
+    while (carry && (u < uend)) {
+        carry = (*u++) + 1;
+        (*w++) = carry & DIGIT_MASK;
+        carry >>= BITS_PER_DIGIT;
+    }
+
+    // Copy the rest of u to the result.
+    while (u < uend)
+        (*w++) = (*u++);
+
+    // Propagate the carry if it is still 1.
+    if (carry)
+        (*w) = 1;
+}
+
+// Compute u += v, where u is vectors, and v is a scalar.
+void
+vec_add_small_on(int ulen, sc_digit *u, sc_digit v)
+{
+#ifdef DEBUG_SYSTEMC
+    sc_assert((ulen > 0) && (u != NULL));
+#endif
+
+    int i = 0;
+
+    while (v && (i < ulen)) {
+        v += u[i];
+        u[i++] = v & DIGIT_MASK;
+        v >>= BITS_PER_DIGIT;
+    }
+
+#ifdef   DEBUG_SYSTEMC
+    if (v != 0) {
+        SC_REPORT_WARNING(sc_core::SC_ID_WITHOUT_MESSAGE_,
+                          "vec_add_small_on( int, sc_digit*, unsigned "
+                          "long ) : "
+                          "result of addition is wrapped around");
+    }
+#endif
+}
+
+// Compute w = u - v, where w, u, and v are vectors.
+// - ulen >= vlen
+// - wlen >= sc_max(ulen, vlen)
+void
+vec_sub(int ulen, const sc_digit *u, int vlen, const sc_digit *v, sc_digit *w)
+{
+#ifdef DEBUG_SYSTEMC
+    sc_assert((ulen > 0) && (u != NULL));
+    sc_assert((vlen > 0) && (v != NULL));
+    sc_assert(w != NULL);
+    sc_assert(ulen >= vlen);
+#endif
+
+    const sc_digit *uend = (u + ulen);
+    const sc_digit *vend = (v + vlen);
+
+    sc_digit borrow = 0; // Also used as diff to save space.
+
+    // Subtract along the shorter v.
+    while (v < vend) {
+        borrow = ((*u++) + DIGIT_RADIX) - (*v++) - borrow;
+        (*w++) = borrow & DIGIT_MASK;
+        borrow = 1 - (borrow >> BITS_PER_DIGIT);
+    }
+
+    // Propagate the borrow.
+    while (borrow && (u < uend)) {
+        borrow = ((*u++) + DIGIT_RADIX) - 1;
+        (*w++) = borrow & DIGIT_MASK;
+        borrow = 1 - (borrow >> BITS_PER_DIGIT);
+    }
+
+#ifdef DEBUG_SYSTEMC
+    sc_assert(borrow == 0);
+#endif
+
+    // Copy the rest of u to the result.
+    while (u < uend)
+        (*w++) = (*u++);
+}
+
+// Compute u = u - v, where u and v are vectors.
+// - u > v
+// - ulen >= vlen
+void
+vec_sub_on(int ulen, sc_digit *ubegin, int vlen, const sc_digit *v)
+{
+#ifdef DEBUG_SYSTEMC
+    sc_assert((ulen > 0) && (ubegin != NULL));
+    sc_assert((vlen > 0) && (v != NULL));
+    sc_assert(ulen >= vlen);
+#endif
+
+    sc_digit *u = ubegin;
+    const sc_digit *uend = (u + ulen);
+    const sc_digit *vend = (v + vlen);
+
+    sc_digit borrow = 0;   // Also used as diff to save space.
+
+    // Subtract along the shorter v.
+    while (v < vend) {
+        borrow = ((*u) + DIGIT_RADIX) - (*v++) - borrow;
+        (*u++) = borrow & DIGIT_MASK;
+        borrow = 1 - (borrow >> BITS_PER_DIGIT);
+    }
+
+    // Propagate the borrow.
+    while (borrow && (u < uend)) {
+        borrow = ((*u) + DIGIT_RADIX) - 1;
+        (*u++) = borrow & DIGIT_MASK;
+        borrow = 1 - (borrow >> BITS_PER_DIGIT);
+    }
+
+#ifdef DEBUG_SYSTEMC
+    sc_assert(borrow == 0);
+#endif
+}
+
+// Compute u = v - u, where u and v are vectors.
+// - v > u
+// - ulen <= vlen or ulen > ulen
+void
+vec_sub_on2(int ulen, sc_digit *ubegin, int vlen, const sc_digit *v)
+{
+#ifdef DEBUG_SYSTEMC
+    sc_assert((ulen > 0) && (ubegin != NULL));
+    sc_assert((vlen > 0) && (v != NULL));
+#endif
+
+    sc_digit *u = ubegin;
+    const sc_digit *uend = (u + sc_min(ulen, vlen));
+
+    sc_digit borrow = 0;   // Also used as diff to save space.
+
+    // Subtract along the shorter u.
+    while (u < uend) {
+        borrow = ((*v++) + DIGIT_RADIX) - (*u) - borrow;
+        (*u++) = borrow & DIGIT_MASK;
+        borrow = 1 - (borrow >> BITS_PER_DIGIT);
+    }
+
+#ifdef DEBUG_SYSTEMC
+    if (borrow != 0) {
+        SC_REPORT_WARNING(sc_core::SC_ID_WITHOUT_MESSAGE_,
+                          "vec_sub_on2( int, sc_digit*, int, const "
+                          "sc_digit* ) : "
+                          "result of subtraction is wrapped around");
+    }
+#endif
+}
+
+// Compute w = u - v, where w and u are vectors, and v is a scalar.
+void
+vec_sub_small(int ulen, const sc_digit *u, sc_digit v, sc_digit *w)
+{
+#ifdef DEBUG_SYSTEMC
+    sc_assert(ulen > 0);
+    sc_assert(u != NULL);
+#endif
+
+    const sc_digit *uend = (u + ulen);
+
+    // Add along the shorter v.
+    sc_digit borrow = ((*u++) + DIGIT_RADIX) - v;
+    (*w++) = borrow & DIGIT_MASK;
+    borrow = 1 - (borrow >> BITS_PER_DIGIT);
+
+    // Propagate the borrow.
+    while (borrow && (u < uend)) {
+        borrow = ((*u++) + DIGIT_RADIX) - 1;
+        (*w++) = borrow & DIGIT_MASK;
+        borrow = 1 - (borrow >> BITS_PER_DIGIT);
+    }
+
+#ifdef   DEBUG_SYSTEMC
+    sc_assert(borrow == 0);
+#endif
+
+    // Copy the rest of u to the result.
+    while (u < uend)
+        (*w++) = (*u++);
+}
+
+
+// Compute u -= v, where u is vectors, and v is a scalar.
+void
+vec_sub_small_on(int ulen, sc_digit *u, sc_digit v)
+{
+#ifdef DEBUG_SYSTEMC
+    sc_assert((ulen > 0) && (u != NULL));
+#endif
+
+    for (int i = 0; i < ulen; ++i) {
+      v = (u[i] + DIGIT_RADIX) - v;
+      u[i] = v & DIGIT_MASK;
+      v = 1 - (v >> BITS_PER_DIGIT);
+    }
+
+#ifdef DEBUG_SYSTEMC
+    sc_assert(v == 0);
+#endif
+}
+
+// Compute w = u * v, where w, u, and v are vectors.
+void
+vec_mul(int ulen, const sc_digit *u, int vlen, const sc_digit *vbegin,
+        sc_digit *wbegin)
+{
+
+  /* Consider u = Ax + B and v = Cx + D where x is equal to
+     HALF_DIGIT_RADIX. In other words, A is the higher half of u and
+     B is the lower half of u. The interpretation for v is
+     similar. Then, we have the following picture:
+
+              u_h     u_l
+     u: -------- --------
+               A        B
+
+              v_h     v_l
+     v: -------- --------
+               C        D
+
+     result (d):
+     carry_before:                           -------- --------
+                                              carry_h  carry_l
+     result_before:        -------- -------- -------- --------
+                               R1_h     R1_l     R0_h     R0_l
+                                             -------- --------
+                                                 BD_h     BD_l
+                                    -------- --------
+                                        AD_h     AD_l
+                                    -------- --------
+                                        BC_h     BC_l
+                           -------- --------
+                               AC_h     AC_l
+     result_after:         -------- -------- -------- --------
+                              R1_h'    R1_l'    R0_h'    R0_l'
+
+     prod_l = R0_h|R0_l + B * D  + 0|carry_l
+            = R0_h|R0_l + BD_h|BD_l + 0|carry_l
+
+     prod_h = A * D + B * C + high_half(prod_l) + carry_h
+            = AD_h|AD_l + BC_h|BC_l + high_half(prod_l) + 0|carry_h
+
+     carry = A * C + high_half(prod_h)
+           = AC_h|AC_l + high_half(prod_h)
+
+     R0_l' = low_half(prod_l)
+
+     R0_h' = low_half(prod_h)
+
+     R0 = high_half(prod_h)|low_half(prod_l)
+
+     where '|' is the concatenation operation and the suffixes 0 and 1
+     show the iteration number, i.e., 0 is the current iteration and 1
+     is the next iteration.
+
+     NOTE: sc_max(prod_l, prod_h, carry) <= 2 * x^2 - 1, so any
+     of these numbers can be stored in a digit.
+
+     NOTE: low_half(u) returns the lower BITS_PER_HALF_DIGIT of u,
+     whereas high_half(u) returns the rest of the bits, which may
+     contain more bits than BITS_PER_HALF_DIGIT.
+  */
+
+#ifdef DEBUG_SYSTEMC
+    sc_assert((ulen > 0) && (u != NULL));
+    sc_assert((vlen > 0) && (vbegin != NULL));
+    sc_assert(wbegin != NULL);
+#endif
+
+#define prod_h carry
+    const sc_digit *uend = (u + ulen);
+    const sc_digit *vend = (vbegin + vlen);
+
+    while (u < uend) {
+        sc_digit u_h = (*u++); // A|B
+        sc_digit u_l = low_half(u_h); // B
+        u_h = high_half(u_h); // A
+
+#ifdef DEBUG_SYSTEMC
+        // The overflow bits must be zero.
+        sc_assert(u_h == (u_h & HALF_DIGIT_MASK));
+#endif
+        sc_digit carry = 0;
+        sc_digit *w = (wbegin++);
+        const sc_digit *v = vbegin;
+
+        while (v < vend) {
+            sc_digit v_h = (*v++); // C|D
+            sc_digit v_l = low_half(v_h); // D
+
+            v_h = high_half(v_h); // C
+
+#ifdef   DEBUG_SYSTEMC
+            // The overflow bits must be zero.
+            sc_assert(v_h == (v_h & HALF_DIGIT_MASK));
+#endif
+
+            sc_digit prod_l = (*w) + u_l * v_l + low_half(carry);
+            prod_h = u_h * v_l + u_l * v_h +
+                high_half(prod_l) + high_half(carry);
+            (*w++) = concat(low_half(prod_h), low_half(prod_l));
+            carry = u_h * v_h + high_half(prod_h);
+        }
+        (*w) = carry;
+    }
+#undef prod_h
+}
+
+// Compute w = u * v, where w and u are vectors, and v is a scalar.
+// - 0 < v < HALF_DIGIT_RADIX.
+void
+vec_mul_small(int ulen, const sc_digit *u, sc_digit v, sc_digit *w)
+{
+#ifdef DEBUG_SYSTEMC
+    sc_assert((ulen > 0) && (u != NULL));
+    sc_assert(w != NULL);
+    sc_assert((0 < v) && (v < HALF_DIGIT_RADIX));
+#endif
+
+#define prod_h carry
+
+    const sc_digit *uend = (u + ulen);
+    sc_digit carry = 0;
+    while (u < uend) {
+        sc_digit u_AB = (*u++);
+#ifdef DEBUG_SYSTEMC
+        // The overflow bits must be zero.
+        sc_assert(high_half(u_AB) == high_half_masked(u_AB));
+#endif
+        sc_digit prod_l = v * low_half(u_AB) + low_half(carry);
+        prod_h = v * high_half(u_AB) + high_half(prod_l) + high_half(carry);
+        (*w++) = concat(low_half(prod_h), low_half(prod_l));
+        carry = high_half(prod_h);
+    }
+    (*w) = carry;
+#undef prod_h
+}
+
+// Compute u = u * v, where u is a vector, and v is a scalar.
+// - 0 < v < HALF_DIGIT_RADIX.
+void
+vec_mul_small_on(int ulen, sc_digit *u, sc_digit v)
+{
+#ifdef DEBUG_SYSTEMC
+    sc_assert((ulen > 0) && (u != NULL));
+    sc_assert((0 < v) && (v < HALF_DIGIT_RADIX));
+#endif
+
+#define   prod_h carry
+    sc_digit carry = 0;
+    for (int i = 0; i < ulen; ++i) {
+#ifdef DEBUG_SYSTEMC
+        // The overflow bits must be zero.
+        sc_assert(high_half(u[i]) == high_half_masked(u[i]));
+#endif
+        sc_digit prod_l = v * low_half(u[i]) + low_half(carry);
+        prod_h = v * high_half(u[i]) + high_half(prod_l) + high_half(carry);
+        u[i] = concat(low_half(prod_h), low_half(prod_l));
+        carry = high_half(prod_h);
+    }
+#undef   prod_h
+
+#ifdef   DEBUG_SYSTEMC
+    if (carry != 0) {
+        SC_REPORT_WARNING(sc_core::SC_ID_WITHOUT_MESSAGE_,
+                          "vec_mul_small_on( int, sc_digit*, unsigned "
+                          "long ) : "
+                          "result of multiplication is wrapped around");
+    }
+#endif
+}
+
+// Compute w = u / v, where w, u, and v are vectors.
+// - u and v are assumed to have at least two digits as uchars.
+void
+vec_div_large(int ulen, const sc_digit *u, int vlen, const sc_digit *v,
+              sc_digit *w)
+{
+#ifdef DEBUG_SYSTEMC
+    sc_assert((ulen > 0) && (u != NULL));
+    sc_assert((vlen > 0) && (v != NULL));
+    sc_assert(w != NULL);
+    sc_assert(BITS_PER_DIGIT >= 3 * BITS_PER_BYTE);
+#endif
+
+    // We will compute q = x / y where x = u and y = v. The reason for
+    // using x and y is that x and y are BYTE_RADIX copies of u and v,
+    // respectively. The use of BYTE_RADIX radix greatly simplifies the
+    // complexity of the division operation. These copies are also
+    // needed even when we use DIGIT_RADIX representation.
+
+    int xlen = BYTES_PER_DIGIT * ulen + 1;
+    int ylen = BYTES_PER_DIGIT * vlen;
+
+#ifdef SC_MAX_NBITS
+    uchar x[DIV_CEIL2(SC_MAX_NBITS, BITS_PER_BYTE)];
+    uchar y[DIV_CEIL2(SC_MAX_NBITS, BITS_PER_BYTE)];
+    uchar q[DIV_CEIL2(SC_MAX_NBITS, BITS_PER_BYTE)];
+#else
+    uchar *x = new uchar[xlen];
+    uchar *y = new uchar[ylen];
+    // valgrind complains about us accessing too far to so leave a buffer.
+    uchar *q = new uchar[(xlen - ylen) + 10];
+#endif
+
+    // q corresponds to w.
+
+    // Set (uchar) x = (sc_digit) u.
+    xlen = vec_to_char(ulen, u, xlen, x);
+
+    // Skip all the leading zeros in x.
+    while ((--xlen >= 0) && (! x[xlen]))
+        continue;
+    xlen++;
+
+    // Set (uchar) y = (sc_digit) v.
+    ylen = vec_to_char(vlen, v, ylen, y);
+
+    // Skip all the leading zeros in y.
+    while ((--ylen >= 0) && (! y[ylen]))
+        continue;
+    ylen++;
+
+#ifdef DEBUG_SYSTEMC
+    sc_assert(xlen > 1);
+    sc_assert(ylen > 1);
+#endif
+
+    // At this point, all the leading zeros are eliminated from x and y.
+
+    // Zero the last digit of x.
+    x[xlen] = 0;
+
+    // The first two digits of y.
+    sc_digit y2 = (y[ylen - 1] << BITS_PER_BYTE) + y[ylen - 2];
+
+    const sc_digit DOUBLE_BITS_PER_BYTE = 2 * BITS_PER_BYTE;
+
+    // Find each q[k].
+    for (int k = (xlen - ylen); k >= 0; --k) {
+        // qk is a guess for q[k] such that q[k] = qk or qk - 1.
+        sc_digit qk;
+
+        // Find qk by just using 2 digits of y and 3 digits of x. The
+        // following code assumes that sizeof(sc_digit) >= 3 BYTEs.
+        int k2 = k + ylen;
+
+        qk = ((x[k2] << DOUBLE_BITS_PER_BYTE) +
+              (x[k2 - 1] << BITS_PER_BYTE) + x[k2 - 2]) / y2;
+
+        if (qk >= BYTE_RADIX) // qk cannot be larger than the largest
+            qk = BYTE_RADIX - 1; // digit in BYTE_RADIX.
+
+        // q[k] = qk or qk - 1. The following if-statement determines which:
+        if (qk) {
+            uchar *xk = (x + k);  // A shortcut for x[k].
+
+            // x = x - y * qk :
+            sc_digit carry = 0;
+
+            for (int i = 0; i < ylen; ++i) {
+                carry += y[i] * qk;
+                sc_digit diff = (xk[i] + BYTE_RADIX) - (carry & BYTE_MASK);
+                xk[i] = (uchar)(diff & BYTE_MASK);
+                carry = (carry >> BITS_PER_BYTE) +
+                    (1 - (diff >> BITS_PER_BYTE));
+            }
+
+            // If carry, qk may be one too large.
+            if (carry) {
+                // 2's complement the last digit.
+                carry = (xk[ylen] + BYTE_RADIX) - carry;
+                xk[ylen] = (uchar)(carry & BYTE_MASK);
+                carry = 1 - (carry >> BITS_PER_BYTE);
+
+                if (carry) {
+
+                  // qk was one too large, so decrement it.
+                  --qk;
+
+                  // Since qk was decreased by one, y must be added to x:
+                  // x = x - y * (qk - 1) = x - y * qk + y = x_above + y.
+                  carry = 0;
+
+                  for (int i = 0; i < ylen; ++i) {
+                      carry += xk[i] + y[i];
+                      xk[i] = (uchar)(carry & BYTE_MASK);
+                      carry >>= BITS_PER_BYTE;
+                  }
+
+                  if (carry)
+                      xk[ylen] = (uchar)((xk[ylen] + 1) & BYTE_MASK);
+
+                }  // second if carry
+            }  // first if carry
+        }  // if qk
+        q[k] = (uchar)qk;
+    }  // for k
+
+    // Set (sc_digit) w = (uchar) q.
+    vec_from_char(xlen - ylen + 1, q, ulen, w);
+
+#ifndef SC_MAX_NBITS
+    delete [] x;
+    delete [] y;
+    delete [] q;
+#endif
+
+}
+
+// Compute w = u / v, where u and w are vectors, and v is a scalar.
+// - 0 < v < HALF_DIGIT_RADIX. Below, we rename w to q.
+void
+vec_div_small(int ulen, const sc_digit *u, sc_digit v, sc_digit *q)
+{
+    // Given (u = u_1u_2...u_n)_b = (q = q_1q_2...q_n) * v + r, where b
+    // is the base, and 0 <= r < v. Then, the algorithm is as follows:
+    //
+    // r = 0;
+    // for (j = 1; j <= n; j++) {
+    //   q_j = (r * b + u_j) / v;
+    //   r = (r * b + u_j) % v;
+    // }
+    //
+    // In our case, b = DIGIT_RADIX, and u = Ax + B and q = Cx + D where
+    // x = HALF_DIGIT_RADIX. Note that r < v < x and b = x^2. Then, a
+    // typical situation is as follows:
+    //
+    // ---- ----
+    // 0    r
+    //           ---- ----
+    //           A    B
+    //      ---- ---- ----
+    //      r    A    B     = r * b + u
+    //
+    // Hence, C = (r|A) / v.
+    //        D = (((r|A) % v)|B) / v
+    //        r = (((r|A) % v)|B) % v
+
+#ifdef DEBUG_SYSTEMC
+    sc_assert((ulen > 0) && (u != NULL));
+    sc_assert(q != NULL);
+    sc_assert((0 < v) && (v < HALF_DIGIT_RADIX));
+#endif
+
+#define q_h r
+    sc_digit r = 0;
+    const sc_digit *ubegin = u;
+
+    u += ulen;
+    q += ulen;
+
+    while (ubegin < u) {
+        sc_digit u_AB = (*--u); // A|B
+
+#ifdef DEBUG_SYSTEMC
+        // The overflow bits must be zero.
+        sc_assert(high_half(u_AB) == high_half_masked(u_AB));
+#endif
+
+        sc_digit num = concat(r, high_half(u_AB)); // num = r|A
+        q_h = num / v; // C
+        num = concat((num % v), low_half(u_AB)); // num = (((r|A) % v)|B)
+        (*--q) = concat(q_h, num / v); // q = C|D
+        r = num % v;
+    }
+#undef q_h
+}
+
+// Compute w = u % v, where w, u, and v are vectors.
+// - u and v are assumed to have at least two digits as uchars.
+void
+vec_rem_large(int ulen, const sc_digit *u, int vlen, const sc_digit *v,
+              sc_digit *w)
+{
+#ifdef DEBUG_SYSTEMC
+    sc_assert((ulen > 0) && (u != NULL));
+    sc_assert((vlen > 0) && (v != NULL));
+    sc_assert(w != NULL);
+    sc_assert(BITS_PER_DIGIT >= 3 * BITS_PER_BYTE);
+#endif
+
+    // This function is adapted from vec_div_large.
+    int xlen = BYTES_PER_DIGIT * ulen + 1;
+    int ylen = BYTES_PER_DIGIT * vlen;
+
+#ifdef SC_MAX_NBITS
+    uchar x[DIV_CEIL2(SC_MAX_NBITS, BITS_PER_BYTE)];
+    uchar y[DIV_CEIL2(SC_MAX_NBITS, BITS_PER_BYTE)];
+#else
+    uchar *x = new uchar[xlen];
+    uchar *y = new uchar[ylen];
+#endif
+
+    // r corresponds to w.
+
+    // Set (uchar) x = (sc_digit) u.
+    xlen = vec_to_char(ulen, u, xlen, x);
+
+    // Skip all the leading zeros in x.
+    while ((--xlen >= 0) && (!x[xlen]))
+        continue;
+    xlen++;
+
+    // Set (uchar) y = (sc_digit) v.
+    ylen = vec_to_char(vlen, v, ylen, y);
+
+    // Skip all the leading zeros in y.
+    while ((--ylen >= 0) && (!y[ylen]))
+        continue;
+    ylen++;
+
+#ifdef DEBUG_SYSTEMC
+    sc_assert(xlen > 1);
+    sc_assert(ylen > 1);
+#endif
+
+    // At this point, all the leading zeros are eliminated from x and y.
+
+    // Zero the last digit of x.
+    x[xlen] = 0;
+
+    // The first two digits of y.
+    sc_digit y2 = (y[ylen - 1] << BITS_PER_BYTE) + y[ylen - 2];
+
+    const sc_digit DOUBLE_BITS_PER_BYTE = 2 * BITS_PER_BYTE;
+
+    // Find each q[k].
+    for (int k = xlen - ylen; k >= 0; --k) {
+        // qk is a guess for q[k] such that q[k] = qk or qk - 1.
+        sc_digit qk;
+
+        // Find qk by just using 2 digits of y and 3 digits of x. The
+        // following code assumes that sizeof(sc_digit) >= 3 BYTEs.
+        int k2 = k + ylen;
+
+        qk = ((x[k2] << DOUBLE_BITS_PER_BYTE) +
+            (x[k2 - 1] << BITS_PER_BYTE) + x[k2 - 2]) / y2;
+
+        if (qk >= BYTE_RADIX) // qk cannot be larger than the largest
+            qk = BYTE_RADIX - 1; // digit in BYTE_RADIX.
+
+        // q[k] = qk or qk - 1. The following if-statement determines which.
+        if (qk) {
+            uchar *xk = (x + k);  // A shortcut for x[k].
+
+            // x = x - y * qk;
+            sc_digit carry = 0;
+
+            for (int i = 0; i < ylen; ++i) {
+                carry += y[i] * qk;
+                sc_digit diff = (xk[i] + BYTE_RADIX) - (carry & BYTE_MASK);
+                xk[i] = (uchar)(diff & BYTE_MASK);
+                carry = (carry >> BITS_PER_BYTE) +
+                    (1 - (diff >> BITS_PER_BYTE));
+            }
+
+            if (carry) {
+                // 2's complement the last digit.
+                carry = (xk[ylen] + BYTE_RADIX) - carry;
+                xk[ylen] = (uchar)(carry & BYTE_MASK);
+                carry = 1 - (carry >> BITS_PER_BYTE);
+
+                if (carry) {
+                  // qk was one too large, so decrement it.
+                  // --qk;
+
+                  // x = x - y * (qk - 1) = x - y * qk + y = x_above + y.
+                  carry = 0;
+
+                  for (int i = 0; i < ylen; ++i) {
+                      carry += xk[i] + y[i];
+                      xk[i] = (uchar)(carry & BYTE_MASK);
+                      carry >>= BITS_PER_BYTE;
+                  }
+
+                  if (carry)
+                      xk[ylen] = (uchar)((xk[ylen] + 1) & BYTE_MASK);
+                }  // second if carry
+            } // first if carry
+        }  // if qk
+    }  // for k
+
+    // Set (sc_digit) w = (uchar) x for the remainder.
+    vec_from_char(ylen, x, ulen, w);
+
+#ifndef SC_MAX_NBITS
+    delete [] x;
+    delete [] y;
+#endif
+
+}
+
+// Compute r = u % v, where u is a vector, and r and v are scalars.
+// - 0 < v < HALF_DIGIT_RADIX.
+// - The remainder r is returned.
+sc_digit
+vec_rem_small(int ulen, const sc_digit *u, sc_digit v)
+{
+
+#ifdef DEBUG_SYSTEMC
+    sc_assert((ulen > 0) && (u != NULL));
+    sc_assert((0 < v) && (v < HALF_DIGIT_RADIX));
+#endif
+
+    // This function is adapted from vec_div_small().
+
+    sc_digit r = 0;
+    const sc_digit *ubegin = u;
+
+    u += ulen;
+
+    while (ubegin < u) {
+        sc_digit u_AB = (*--u); // A|B
+#ifdef DEBUG_SYSTEMC
+        // The overflow bits must be zero.
+        sc_assert(high_half(u_AB) == high_half_masked(u_AB));
+#endif
+        // r = (((r|A) % v)|B) % v
+        r = (concat(((concat(r, high_half(u_AB))) % v), low_half(u_AB))) % v;
+    }
+
+    return r;
+}
+
+// u = u / v, r = u % v.
+sc_digit
+vec_rem_on_small(int ulen, sc_digit *u, sc_digit v)
+{
+#ifdef DEBUG_SYSTEMC
+    sc_assert((ulen > 0) && (u != NULL));
+    sc_assert(v > 0);
+#endif
+
+#define q_h r
+    sc_digit r = 0;
+    const sc_digit *ubegin = u;
+
+    u += ulen;
+    while (ubegin < u) {
+        sc_digit u_AB = (*--u); // A|B
+#ifdef DEBUG_SYSTEMC
+        // The overflow bits must be zero.
+        sc_assert(high_half(u_AB) == high_half_masked(u_AB));
+#endif
+        sc_digit num = concat(r, high_half(u_AB)); // num = r|A
+        q_h = num / v; // C
+        num = concat((num % v), low_half(u_AB)); // num = (((r|A) % v)|B)
+        (*u) = concat(q_h, num / v); // q = C|D
+        r = num % v;
+    }
+#undef q_h
+    return r;
+}
+
+// Set (uchar) v = (sc_digit) u. Return the new vlen.
+int
+vec_to_char(int ulen, const sc_digit *u, int vlen, uchar *v)
+{
+#ifdef DEBUG_SYSTEMC
+    sc_assert((ulen > 0) && (u != NULL));
+    sc_assert((vlen > 0) && (v != NULL));
+#endif
+
+    int nbits = ulen * BITS_PER_DIGIT;
+    int right = 0;
+    int left = right + BITS_PER_BYTE - 1;
+
+    vlen = 0;
+    while (nbits > 0) {
+        int left_digit = left / BITS_PER_DIGIT;
+        int right_digit = right / BITS_PER_DIGIT;
+        int nsr = ((vlen << LOG2_BITS_PER_BYTE) % BITS_PER_DIGIT);
+        int d = u[right_digit] >> nsr;
+
+        if (left_digit != right_digit) {
+            if (left_digit < ulen)
+                d |= u[left_digit] << (BITS_PER_DIGIT - nsr);
+        }
+
+        v[vlen++] = (uchar)(d & BYTE_MASK);
+
+        left += BITS_PER_BYTE;
+        right += BITS_PER_BYTE;
+        nbits -= BITS_PER_BYTE;
+    }
+    return vlen;
+}
+
+// Set (sc_digit) v = (uchar) u.
+// - sizeof(uchar) <= sizeof(sc_digit),
+void
+vec_from_char(int ulen, const uchar *u, int vlen, sc_digit *v)
+{
+#ifdef DEBUG_SYSTEMC
+    sc_assert((ulen > 0) && (u != NULL));
+    sc_assert((vlen > 0) && (v != NULL));
+    sc_assert(sizeof(uchar) <= sizeof(sc_digit));
+#endif
+
+    sc_digit *vend = (v + vlen);
+
+    const int nsr = BITS_PER_DIGIT - BITS_PER_BYTE;
+    const sc_digit mask = one_and_ones(nsr);
+
+    (*v) = (sc_digit) u[ulen - 1];
+
+    for (int i = ulen - 2; i >= 0; --i) {
+        // Manual inlining of vec_shift_left().
+        sc_digit *viter = v;
+        sc_digit carry = 0;
+        while (viter < vend) {
+            sc_digit vval = (*viter);
+            (*viter++) = (((vval & mask) << BITS_PER_BYTE) | carry);
+            carry = vval >> nsr;
+        }
+
+        if (viter < vend)
+            (*viter) = carry;
+
+        (*v) |= (sc_digit)u[i];
+    }
+}
+
+// Set u <<= nsl.
+// If nsl is negative, it is ignored.
+void
+vec_shift_left(int ulen, sc_digit *u, int nsl)
+{
+#ifdef DEBUG_SYSTEMC
+    sc_assert((ulen > 0) && (u != NULL));
+#endif
+
+    if (nsl <= 0)
+        return;
+
+    // Shift left whole digits if nsl is large enough.
+    if (nsl >= (int) BITS_PER_DIGIT) {
+        int nd;
+        if (nsl % BITS_PER_DIGIT == 0) {
+            nd = nsl / BITS_PER_DIGIT; // No need to use DIV_CEIL(nsl).
+            nsl = 0;
+        } else {
+            nd = DIV_CEIL(nsl) - 1;
+            nsl -= nd * BITS_PER_DIGIT;
+        }
+
+        if (nd) {
+            // Shift left for nd digits.
+            for (int j = ulen - 1; j >= nd; --j)
+                u[j] = u[j - nd];
+
+            vec_zero(sc_min(nd, ulen), u);
+        }
+        if (nsl == 0)
+            return;
+    }
+
+    // Shift left if nsl < BITS_PER_DIGIT.
+    sc_digit *uiter = u;
+    sc_digit *uend = uiter + ulen;
+
+    int nsr = BITS_PER_DIGIT - nsl;
+    sc_digit mask = one_and_ones(nsr);
+
+    sc_digit carry = 0;
+
+    while (uiter < uend) {
+        sc_digit uval = (*uiter);
+        (*uiter++) = (((uval & mask) << nsl) | carry);
+        carry = uval >> nsr;
+    }
+
+    if (uiter < uend)
+        (*uiter) = carry;
+}
+
+// Set u >>= nsr.
+// If nsr is negative, it is ignored.
+void
+vec_shift_right(int ulen, sc_digit *u, int nsr, sc_digit fill)
+{
+#ifdef DEBUG_SYSTEMC
+    sc_assert((ulen > 0) && (u != NULL));
+#endif
+
+    // fill is usually either 0 or DIGIT_MASK; it can be any value.
+    if (nsr <= 0)
+        return;
+
+    // Shift right whole digits if nsr is large enough.
+    if (nsr >= (int) BITS_PER_DIGIT) {
+        int nd;
+        if (nsr % BITS_PER_DIGIT == 0) {
+            nd = nsr / BITS_PER_DIGIT;
+            nsr = 0;
+        } else {
+            nd = DIV_CEIL(nsr) - 1;
+            nsr -= nd * BITS_PER_DIGIT;
+        }
+
+        if (nd) {
+            // Shift right for nd digits.
+            for (int j = 0; j < (ulen - nd); ++j)
+                u[j] = u[j + nd];
+
+            if (fill) {
+                for (int j = ulen - sc_min( nd, ulen ); j < ulen; ++j)
+                    u[j] = fill;
+            } else {
+                vec_zero(ulen - sc_min( nd, ulen ), ulen, u);
+            }
+        }
+        if (nsr == 0)
+          return;
+    }
+
+    // Shift right if nsr < BITS_PER_DIGIT.
+    sc_digit *ubegin = u;
+    sc_digit *uiter = (ubegin + ulen);
+
+    int nsl = BITS_PER_DIGIT - nsr;
+    sc_digit mask = one_and_ones(nsr);
+
+    sc_digit carry = (fill & mask) << nsl;
+
+    while (ubegin < uiter) {
+        sc_digit uval = (*--uiter);
+        (*uiter) = (uval >> nsr) | carry;
+        carry = (uval & mask) << nsl;
+    }
+}
+
+
+// Let u[l..r], where l and r are left and right bit positions
+// respectively, be equal to its mirror image.
+void
+vec_reverse(int unb, int und, sc_digit *ud, int l, int r)
+{
+#ifdef DEBUG_SYSTEMC
+    sc_assert((unb > 0) && (und > 0) && (ud != NULL));
+    sc_assert((0 <= r) && (r <= l) && (l < unb));
+#endif
+
+    if (l < r) {
+        std::stringstream msg;
+        msg << "vec_reverse( int, int, sc_digit*, int l, int r ) : " <<
+               "l = " << l << " < r = " << r << " is not valid",
+        SC_REPORT_ERROR("conversion failed", msg.str().c_str());
+        return;
+    }
+
+    // Make sure that l and r are within bounds.
+    r = sc_max(r, 0);
+    l = sc_min(l, unb - 1);
+
+    // Allocate memory for processing.
+#ifdef SC_MAX_NBITS
+    sc_digit d[MAX_NDIGITS];
+#else
+    sc_digit *d = new sc_digit[und];
+#endif
+
+    // d is a copy of ud.
+    vec_copy(und, d, ud);
+
+    // Based on the value of the ith in d, find the value of the jth bit
+    // in ud.
+    for (int i = l, j = r; i >= r; --i, ++j) {
+        if ((d[digit_ord(i)] & one_and_zeros(bit_ord(i))) != 0) // Test.
+            ud[digit_ord(j)] |= one_and_zeros(bit_ord(j)); // Set.
+        else
+            ud[digit_ord(j)] &= ~(one_and_zeros(bit_ord(j))); // Clear.
+    }
+
+#ifndef SC_MAX_NBITS
+    delete [] d;
+#endif
+}
+
+#ifdef SC_MAX_NBITS
+void test_bound_failed(int nb)
+{
+    std::stringstream msg;
+    msg << "test_bound( int nb ) : "
+           "nb = " << nb << " > SC_MAX_NBITS = " << SC_MAX_NBITS <<
+           "  is not valid";
+    SC_REPORT_ERROR(sc_core::SC_ID_OUT_OF_BOUNDS_, msg.str().c_str());
+}
+#endif // SC_MAX_NBITS
+
+} // namespace sc_dt
diff --git a/src/systemc/dt/int/sc_signed.cc b/src/systemc/dt/int/sc_signed.cc
new file mode 100644
index 0000000..63a2d03
--- /dev/null
+++ b/src/systemc/dt/int/sc_signed.cc
@@ -0,0 +1,3982 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_signed.cpp -- Arbitrary precision signed arithmetic.
+
+                   This file includes the definitions of sc_signed_bitref,
+                   sc_signed_subref, and sc_signed classes. The first two
+                   classes are proxy classes to reference one bit and a range
+                   of bits of a sc_signed number, respectively. This file also
+                   includes sc_nbcommon.cpp and sc_nbfriends.cpp, which
+                   contain the definitions shared by sc_unsigned.
+
+  Original Author: Ali Dasdan, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: sc_signed.cpp,v $
+// Revision 1.6  2011/02/18 20:19:15  acg
+//  Andy Goodrich: updating Copyright notice.
+//
+// Revision 1.5  2008/12/10 20:38:45  acg
+//  Andy Goodrich: fixed conversion of double values to the digits vector.
+//  The bits above the radix were not being masked off.
+//
+// Revision 1.4  2008/06/19 17:47:56  acg
+//  Andy Goodrich: fixes for bugs. See 2.2.1 RELEASENOTES.
+//
+// Revision 1.3  2008/04/29 21:20:41  acg
+//  Andy Goodrich: added mask to first word transferred when processing
+//  a negative sc_signed value in sc_signed::concat_get_data().
+//
+// Revision 1.2  2007/11/04 21:27:00  acg
+//  Andy Goodrich: changes to make sure the proper value is returned from
+//  concat_get_data().
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.5  2006/10/23 19:32:47  acg
+//  Andy Goodrich: further fix for incorrect value being returned from
+//  concat_get_data. This one is in the non-aligned value code.
+//
+// Revision 1.3  2006/01/13 18:49:32  acg
+// Added $Log command so that CVS check in comments are reproduced in the
+// source.
+//
+
+#include <cctype>
+#include <cmath>
+#include <sstream>
+
+#include "systemc/ext/dt/bit/sc_bv_base.hh"
+#include "systemc/ext/dt/bit/sc_lv_base.hh"
+#include "systemc/ext/dt/fx/sc_fix.hh"
+#include "systemc/ext/dt/fx/scfx_other_defs.hh"
+#include "systemc/ext/dt/int/sc_int_base.hh"
+#include "systemc/ext/dt/int/sc_signed.hh"
+#include "systemc/ext/dt/int/sc_uint_base.hh"
+#include "systemc/ext/dt/int/sc_unsigned.hh"
+#include "systemc/ext/dt/misc/sc_concatref.hh"
+
+// explicit template instantiations
+namespace sc_core
+{
+
+template class sc_vpool<sc_dt::sc_signed_bitref>;
+template class sc_vpool<sc_dt::sc_signed_subref>;
+
+} // namespace sc_core
+
+namespace sc_dt
+{
+
+// Pool of temporary instances:
+
+sc_core::sc_vpool<sc_signed_bitref> sc_signed_bitref::m_pool(9);
+sc_core::sc_vpool<sc_signed_subref> sc_signed_subref::m_pool(9);
+
+void
+sc_signed::invalid_init(const char *type_name, int nb) const
+{
+    std::stringstream msg;
+    msg << "sc_signed("<< type_name << ") : nb = " << nb << " is not valid";
+    SC_REPORT_ERROR("initialization failed", msg.str().c_str());
+}
+
+// ----------------------------------------------------------------------------
+// SECTION: Public members - Invalid selections.
+// ----------------------------------------------------------------------------
+
+void
+sc_signed::invalid_index(int i) const
+{
+    std::stringstream msg;
+    msg << "sc_bigint bit selection: index = " << i << " violates "
+           "0 <= index <= " << (nbits - 1);
+    SC_REPORT_ERROR("out of bounds", msg.str().c_str());
+    sc_core::sc_abort(); // can't recover from here
+}
+
+void
+sc_signed::invalid_range(int l, int r) const
+{
+    std::stringstream msg;
+    msg << "sc_bigint part selection: left = " <<
+           l << ", right = " << r << "\n"
+           "  violates either (" << (nbits-1) << " >= left >= 0) or "
+           "(" << (nbits-1) << " >= right >= 0)";
+    SC_REPORT_ERROR("out of bounds", msg.str().c_str());
+    sc_core::sc_abort(); // can't recover from here
+}
+
+
+// ----------------------------------------------------------------------------
+
+// ----------------------------------------------------------------------------
+//  SECTION: Public members.
+// ----------------------------------------------------------------------------
+
+// Most public members are included from sc_nbcommon.inc. However, some
+// concatenation support appears here to optimize between the signed and
+// unsigned cases.
+
+// Insert this object's value at the specified place in a vector of biguint
+// style values.
+
+bool
+sc_signed::concat_get_ctrl(sc_digit *dst_p, int low_i) const
+{
+    int dst_i; // Index to next word to set in dst_p.
+    int end_i; // Index of high order word to set.
+    int left_shift; // Amount to shift value left.
+    sc_digit mask; // Mask for partial word sets.
+
+    // CALCULATE METRICS FOR DATA MOVEMENT:
+    dst_i = low_i / BITS_PER_DIGIT;
+    end_i = (low_i + nbits - 1) / BITS_PER_DIGIT;
+    left_shift = low_i % BITS_PER_DIGIT;
+
+    // ALL DATA TO BE MOVED IS IN A SINGLE WORD:
+    mask = ~(~0U << left_shift);
+    dst_p[dst_i] = (dst_p[dst_i] & ~mask);
+    dst_i++;
+
+    for (; dst_i <= end_i; dst_i++)
+        dst_p[dst_i] = 0;
+
+    return false;
+}
+
+bool
+sc_signed::concat_get_data(sc_digit *dst_p, int low_i) const
+{
+    sc_digit carry; // Carry bit for complements.
+    int dst_i; // Index to next word to set in dst_p.
+    int end_i; // Index of high order word to set.
+    int high_i; // Index w/in word of high order bit.
+    int left_shift; // Amount to shift value left.
+    sc_digit left_word; // High word component for set.
+    sc_digit mask; // Mask for partial word sets.
+    bool result; // True if inserted non-zero data.
+    int right_shift; // Amount to shift value right.
+    sc_digit right_word; // Low word component for set.
+    int src_i; // Index to next word to get from digit.
+
+    // CALCULATE METRICS FOR DATA MOVEMENT:
+    dst_i = low_i / BITS_PER_DIGIT;
+    high_i = low_i + nbits - 1;
+    end_i = high_i / BITS_PER_DIGIT;
+    left_shift = low_i % BITS_PER_DIGIT;
+
+    switch (sgn) {
+      // POSITIVE SOURCE VALUE:
+      case SC_POS:
+        result = true;
+
+        // ALL DATA TO BE MOVED IS IN A SINGLE WORD:
+        if (dst_i == end_i) {
+            mask = ~(~0U << left_shift);
+            dst_p[dst_i] = ((dst_p[dst_i] & mask) |
+                (digit[0] << left_shift)) & DIGIT_MASK;
+
+        // DATA IS IN MORE THAN ONE WORD, BUT IS WORD ALIGNED:
+        } else if (left_shift == 0) {
+            for (src_i = 0; dst_i < end_i; dst_i++, src_i++) {
+                dst_p[dst_i] = digit[src_i];
+            }
+            high_i = high_i % BITS_PER_DIGIT;
+            mask = ~(~1U << high_i) & DIGIT_MASK;
+            dst_p[dst_i] = digit[src_i] & mask;
+
+        // DATA IS IN MORE THAN ONE WORD, AND NOT WORD ALIGNED:
+        } else {
+            high_i = high_i % BITS_PER_DIGIT;
+            right_shift = BITS_PER_DIGIT - left_shift;
+            mask = ~(~0U << left_shift);
+            right_word = digit[0];
+            dst_p[dst_i] = (dst_p[dst_i] & mask) |
+                ((right_word << left_shift) & DIGIT_MASK);
+            for (src_i = 1, dst_i++; dst_i < end_i; dst_i++, src_i++) {
+                left_word = digit[src_i];
+                dst_p[dst_i] = ((left_word << left_shift)&DIGIT_MASK) |
+                    (right_word >> right_shift);
+                right_word = left_word;
+            }
+            left_word = (src_i < ndigits) ? digit[src_i] : 0;
+            mask = ~(~1U << high_i) & DIGIT_MASK;
+            dst_p[dst_i] = ((left_word << left_shift) |
+                (right_word >> right_shift)) & mask;
+        }
+        break;
+
+      // SOURCE VALUE IS NEGATIVE:
+      case SC_NEG:
+        // ALL DATA TO BE MOVED IS IN A SINGLE WORD:
+        result = true;
+        if (dst_i == end_i) {
+            mask = ~(~0U << nbits);
+            right_word = ((digit[0] ^ DIGIT_MASK) + 1) & mask;
+            mask = ~(~0U << left_shift);
+            dst_p[dst_i] = ((dst_p[dst_i] & mask) |
+                (right_word << left_shift)) & DIGIT_MASK;
+
+        // DATA IS IN MORE THAN ONE WORD, BUT IS WORD ALIGNED:
+        } else if (left_shift == 0) {
+            carry = 1;
+            for (src_i = 0; dst_i < end_i; dst_i++, src_i++) {
+                right_word = (digit[src_i] ^ DIGIT_MASK) + carry;
+                dst_p[dst_i] = right_word &  DIGIT_MASK;
+                carry = right_word >> BITS_PER_DIGIT;
+            }
+            high_i = high_i % BITS_PER_DIGIT;
+            mask = (~(~1U << high_i)) & DIGIT_MASK;
+            right_word = (src_i < ndigits) ?
+                (digit[src_i] ^ DIGIT_MASK) + carry : DIGIT_MASK + carry;
+            dst_p[dst_i] = right_word & mask;
+
+        // DATA IS IN MORE THAN ONE WORD, AND NOT WORD ALIGNED:
+        } else {
+            high_i = high_i % BITS_PER_DIGIT;
+            right_shift = BITS_PER_DIGIT - left_shift;
+            mask = ~(~0U << left_shift);
+            carry = 1;
+            right_word = (digit[0] ^ DIGIT_MASK) + carry;
+            dst_p[dst_i] = (dst_p[dst_i] & mask) |
+                ((right_word << left_shift) & DIGIT_MASK);
+            carry = right_word >> BITS_PER_DIGIT;
+            right_word &= DIGIT_MASK;
+            for (src_i = 1, dst_i++; dst_i < end_i; dst_i++, src_i++) {
+                left_word = (digit[src_i] ^ DIGIT_MASK) + carry;
+                dst_p[dst_i] = ((left_word << left_shift)&DIGIT_MASK) |
+                    (right_word >> right_shift);
+                carry = left_word >> BITS_PER_DIGIT;
+                right_word = left_word & DIGIT_MASK;
+            }
+            left_word = (src_i < ndigits) ?
+                (digit[src_i] ^ DIGIT_MASK) + carry : carry;
+            mask = ~(~1U << high_i) & DIGIT_MASK;
+            dst_p[dst_i] = ((left_word << left_shift) |
+                (right_word >> right_shift)) & mask;
+        }
+        break;
+
+      // VALUE IS ZERO:
+      default:
+        result = false;
+        // ALL DATA TO BE MOVED IS IN A SINGLE WORD:
+        if (dst_i == end_i) {
+            mask = ~(~0U << nbits) << left_shift;
+            dst_p[dst_i] = dst_p[dst_i] & ~mask;
+
+        // DATA IS IN MORE THAN ONE WORD, BUT IS WORD ALIGNED:
+        } else if (left_shift == 0) {
+            for (src_i = 0; dst_i < end_i; dst_i++, src_i++) {
+                dst_p[dst_i] = 0;
+            }
+            dst_p[dst_i] = 0;
+
+        // DATA IS IN MORE THAN ONE WORD, AND NOT WORD ALIGNED:
+        } else {
+            mask = ~(~0U << left_shift);
+            dst_p[dst_i] = (dst_p[dst_i] & mask);
+            for (dst_i++; dst_i <= end_i; dst_i++) {
+                dst_p[dst_i] = 0;
+            }
+        }
+        break;
+    }
+    return result;
+}
+
+// Return this object instance's bits as a uint64 without sign extension.
+
+uint64
+sc_signed::concat_get_uint64() const
+{
+    uint64        result;
+    switch (sgn) {
+      case SC_POS:
+        result = 0;
+        if (ndigits > 2)
+            result = digit[2];
+        if (ndigits > 1)
+            result = (result << BITS_PER_DIGIT) | digit[1];
+        result = (result << BITS_PER_DIGIT) | digit[0];
+        break;
+      case SC_NEG:
+        result = 0;
+        if (ndigits > 2)
+            result = digit[2];
+        if (ndigits > 1)
+            result = (result << BITS_PER_DIGIT) | digit[1];
+        result = (result << BITS_PER_DIGIT) | digit[0];
+        result = -result;
+        if (nbits < 64) {
+            uint64 mask = ~0;
+            result = result & ~(mask << nbits);
+        }
+        break;
+      default:
+        result = 0;
+        break;
+    }
+    return result;
+}
+
+// #### OPTIMIZE
+void
+sc_signed::concat_set(int64 src, int low_i)
+{
+    *this = (low_i < 64) ? src >> low_i : src >> 63;
+}
+
+void
+sc_signed::concat_set(const sc_signed &src, int low_i)
+{
+    if (low_i < src.length())
+        *this = src >> low_i;
+    else
+        *this = (src<0) ? (int_type)-1 : 0;
+}
+
+void
+sc_signed::concat_set(const sc_unsigned &src, int low_i)
+{
+    if (low_i < src.length())
+        *this = src >> low_i;
+    else
+        *this = 0;
+}
+
+void
+sc_signed::concat_set(uint64 src, int low_i)
+{
+    *this = (low_i < 64) ? src >> low_i : 0;
+}
+
+// ----------------------------------------------------------------------------
+//  SECTION: Public members - Reduction methods.
+// ----------------------------------------------------------------------------
+
+bool
+sc_signed::and_reduce() const
+{
+    sc_digit current; // Current digit examining.
+    int i; // Index of digit examining.
+
+    if (sgn == SC_NEG) {
+        current = (1 << BITS_PER_DIGIT);
+        for (i = 0; i < ndigits-1; i++) {
+            current = (current >> BITS_PER_DIGIT) + (digit[i]^DIGIT_MASK);
+            if ((current & DIGIT_MASK) != DIGIT_MASK) return false;
+        }
+        current = (current >> BITS_PER_DIGIT) + (digit[i]^DIGIT_MASK);
+        if ((current & ~(~0U << (nbits % BITS_PER_DIGIT))) ==
+             static_cast<sc_digit>(~(~0U << (nbits % BITS_PER_DIGIT)))) {
+            return true;
+        }
+    }
+    return false;
+}
+
+bool
+sc_signed::or_reduce() const
+{
+    return sgn == SC_ZERO ? false : true;
+}
+
+bool
+sc_signed::xor_reduce() const
+{
+    int i; // Digit examining.
+    int odd; // Flag for odd number of digits.
+
+    odd = 0;
+    for (i = 0; i < nbits; i++)
+        if (test(i))
+            odd = ~odd;
+    return odd ? true : false;
+}
+
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Public members - Assignment operators.
+// ----------------------------------------------------------------------------
+
+// assignment operators
+
+const sc_signed &
+sc_signed::operator = (const char *a)
+{
+    if (a == 0) {
+        SC_REPORT_ERROR("conversion failed",
+                        "character string is zero");
+    } else if (*a == 0) {
+        SC_REPORT_ERROR("conversion failed",
+                        "character string is empty");
+    } else try {
+        int len = length();
+        sc_fix aa(a, len, len, SC_TRN, SC_WRAP, 0, SC_ON);
+        return this->operator = (aa);
+    } catch(const sc_core::sc_report &) {
+        std::stringstream msg;
+        msg << "character string '" << a << "' is not valid";
+        SC_REPORT_ERROR("conversion failed", msg.str().c_str());
+    }
+    return *this;
+}
+
+const sc_signed &
+sc_signed::operator=(int64 v)
+{
+    sgn = get_sign(v);
+    // v >= 0 now.
+    if (sgn == SC_ZERO) {
+        vec_zero(ndigits, digit);
+    } else {
+        from_uint(ndigits, digit, (uint64)v);
+        if (nbits <= (int)BITS_PER_INT64)
+            convert_SM_to_2C_to_SM();
+    }
+    return *this;
+}
+
+const sc_signed &
+sc_signed::operator=(uint64 v)
+{
+    sgn = get_sign(v);
+    if (sgn == SC_ZERO) {
+        vec_zero(ndigits, digit);
+    } else {
+        from_uint(ndigits, digit, v);
+        if (nbits <= (int)BITS_PER_INT64)
+            convert_SM_to_2C_to_SM();
+    }
+    return *this;
+}
+
+const sc_signed &
+sc_signed::operator=(long v)
+{
+    sgn = get_sign(v);
+    // v >= 0 now.
+    if (sgn == SC_ZERO) {
+        vec_zero(ndigits, digit);
+    } else {
+        from_uint(ndigits, digit, (unsigned long)v);
+        if (nbits <= (int)BITS_PER_LONG)
+            convert_SM_to_2C_to_SM();
+    }
+    return *this;
+}
+
+const sc_signed &
+sc_signed::operator=(unsigned long v)
+{
+    sgn = get_sign(v);
+    if (sgn == SC_ZERO) {
+        vec_zero(ndigits, digit);
+    } else {
+        from_uint(ndigits, digit, v);
+        if (nbits <= (int)BITS_PER_LONG)
+            convert_SM_to_2C_to_SM();
+    }
+    return *this;
+}
+
+const sc_signed &
+sc_signed::operator=(double v)
+{
+    is_bad_double(v);
+    if (v < 0) {
+        v = -v;
+        sgn = SC_NEG;
+    } else {
+      sgn = SC_POS;
+    }
+
+    int i = 0;
+    while (std::floor(v) && (i < ndigits)) {
+        digit[i++] = ((sc_digit)std::floor(remainder(v, DIGIT_RADIX))) &
+                                           DIGIT_MASK;
+        v /= DIGIT_RADIX;
+    }
+    vec_zero(i, ndigits, digit);
+    convert_SM_to_2C_to_SM();
+    return *this;
+}
+
+
+// ----------------------------------------------------------------------------
+
+const sc_signed &
+sc_signed::operator = (const sc_bv_base &v)
+{
+    int minlen = sc_min(nbits, v.length());
+    int i = 0;
+    for (; i < minlen; ++i) {
+        safe_set(i, v.get_bit(i), digit);
+    }
+    for (; i < nbits; ++i) {
+        safe_set(i, 0, digit); // zero-extend
+    }
+    convert_2C_to_SM();
+    return *this;
+}
+
+const sc_signed &
+sc_signed::operator = (const sc_lv_base &v)
+{
+    int minlen = sc_min(nbits, v.length());
+    int i = 0;
+    for (; i < minlen; ++i) {
+        safe_set(i, sc_logic(v.get_bit(i)).to_bool(), digit);
+    }
+    for (; i < nbits; ++i) {
+        safe_set(i, 0, digit);  // zero-extend
+    }
+    convert_2C_to_SM();
+    return *this;
+}
+
+
+// explicit conversion to character string
+const std::string
+sc_signed::to_string(sc_numrep numrep) const
+{
+    int len = length();
+    sc_fix aa(*this, len, len, SC_TRN, SC_WRAP, 0, SC_ON);
+    return aa.to_string(numrep);
+}
+
+const std::string
+sc_signed::to_string(sc_numrep numrep, bool w_prefix) const
+{
+    int len = length();
+    sc_fix aa(*this, len, len, SC_TRN, SC_WRAP, 0, SC_ON);
+    return aa.to_string(numrep, w_prefix);
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Interfacing with sc_int_base
+// ----------------------------------------------------------------------------
+
+const sc_signed &
+sc_signed::operator = (const sc_int_base &v)
+{
+    return operator = ((int64)v);
+}
+
+
+sc_signed
+operator + (const sc_unsigned &u, const sc_int_base &v)
+{
+    return operator + (u, static_cast<int64>(v));
+}
+
+sc_signed
+operator + (const sc_int_base &u, const sc_unsigned &v)
+{
+    return operator + (static_cast<int64>(u), v);
+}
+
+sc_signed
+operator + (const sc_signed &u, const sc_int_base &v)
+{
+    return operator + (u, (int64)v);
+}
+
+sc_signed
+operator + (const sc_int_base &u, const sc_signed &v)
+{
+    return operator + ((int64)u, v);
+}
+
+const sc_signed &
+sc_signed::operator += (const sc_int_base &v)
+{
+    return operator += ((int64)v);
+}
+
+
+sc_signed
+operator - (const sc_unsigned &u, const sc_int_base &v)
+{
+    return operator - (u, (int64)v);
+}
+
+sc_signed
+operator - (const sc_int_base &u, const sc_unsigned &v)
+{
+    return operator - ((int64)u, v);
+}
+
+sc_signed
+operator - (const sc_signed &u, const sc_int_base &v)
+{
+    return operator - (u, (int64)v);
+}
+
+sc_signed
+operator - (const sc_int_base &u, const sc_signed &v)
+{
+    return operator - ((int64)u, v);
+}
+
+const sc_signed &
+sc_signed::operator -= (const sc_int_base &v)
+{
+    return operator -= ((int64)v);
+}
+
+
+sc_signed
+operator * (const sc_unsigned &u, const sc_int_base &v)
+{
+    return operator * (u, static_cast<int64>(v));
+}
+
+sc_signed
+operator * (const sc_int_base &u, const sc_unsigned &v)
+{
+    return operator * (static_cast<int64>(u), v);
+}
+
+sc_signed
+operator * (const sc_signed &u, const sc_int_base &v)
+{
+    return operator * (u, (int64)v);
+}
+
+sc_signed
+operator * (const sc_int_base &u, const sc_signed &v)
+{
+    return operator * ((int64)u, v);
+}
+
+const sc_signed &
+sc_signed::operator *= (const sc_int_base &v)
+{
+    return operator *= ((int64)v);
+}
+
+
+sc_signed
+operator / (const sc_unsigned &u, const sc_int_base &v)
+{
+    return operator / (u, static_cast<int64>(v));
+}
+
+sc_signed
+operator / (const sc_int_base &u, const sc_unsigned &v)
+{
+    return operator / (static_cast<int64>(u), v);
+}
+
+sc_signed
+operator / (const sc_signed &u, const sc_int_base &v)
+{
+    return operator / (u, (int64)v);
+}
+
+sc_signed
+operator / (const sc_int_base &u, const sc_signed &v)
+{
+    return operator / ((int64)u, v);
+}
+
+const sc_signed &
+sc_signed::operator /= (const sc_int_base &v)
+{
+    return operator /= ((int64)v);
+}
+
+
+sc_signed
+operator % (const sc_unsigned &u, const sc_int_base &v)
+{
+    return operator % (u, static_cast<int64>(v));
+}
+
+sc_signed
+operator % (const sc_int_base &u, const sc_unsigned &v)
+{
+    return operator % (static_cast<int64>(u), v);
+}
+
+sc_signed
+operator % (const sc_signed &u, const sc_int_base &v)
+{
+    return operator % (u, (int64)v);
+}
+
+sc_signed
+operator % (const sc_int_base &u, const sc_signed &v)
+{
+    return operator % ((int64)u, v);
+}
+
+const sc_signed &
+sc_signed::operator %= (const sc_int_base &v)
+{
+    return operator %= ((int64)v);
+}
+
+
+sc_signed
+operator & (const sc_unsigned &u, const sc_int_base &v)
+{
+    return operator & (u, static_cast<int64>(v));
+}
+
+sc_signed
+operator & (const sc_int_base &u, const sc_unsigned &v)
+{
+    return operator & (static_cast<int64>(u), v);
+}
+
+sc_signed
+operator & (const sc_signed &u, const sc_int_base &v)
+{
+    return operator & (u, (int64)v);
+}
+
+sc_signed
+operator & (const sc_int_base &u, const sc_signed &v)
+{
+    return operator & ((int64)u, v);
+}
+
+const sc_signed &
+sc_signed::operator &= (const sc_int_base &v)
+{
+    return operator &= ((int64)v);
+}
+
+
+sc_signed
+operator | (const sc_unsigned &u, const sc_int_base &v)
+{
+    return operator | (u, static_cast<int64>(v));
+}
+
+sc_signed
+operator | (const sc_int_base &u, const sc_unsigned &v)
+{
+    return operator | (static_cast<int64>(u), v);
+}
+
+sc_signed
+operator | (const sc_signed& u, const sc_int_base &v)
+{
+    return operator|(u, (int64)v);
+}
+
+sc_signed
+operator | (const sc_int_base &u, const sc_signed &v)
+{
+    return operator | ((int64)u, v);
+}
+
+const sc_signed &
+sc_signed::operator |= (const sc_int_base &v)
+{
+    return operator |= ((int64)v);
+}
+
+
+sc_signed
+operator ^ (const sc_unsigned &u, const sc_int_base &v)
+{
+    return operator ^ (u, static_cast<int64>(v));
+}
+
+sc_signed
+operator ^ (const sc_int_base &u, const sc_unsigned &v)
+{
+    return operator ^ (static_cast<int64>(u), v);
+}
+
+sc_signed
+operator ^ (const sc_signed &u, const sc_int_base &v)
+{
+    return operator ^ (u, (int64)v);
+}
+
+sc_signed
+operator ^ (const sc_int_base &u, const sc_signed &v)
+{
+    return operator ^ ((int64)u, v);
+}
+
+const sc_signed &
+sc_signed::operator ^= (const sc_int_base &v)
+{
+    return operator ^= ((int64)v);
+}
+
+
+sc_signed
+operator << (const sc_signed &u, const sc_int_base &v)
+{
+    return operator << (u, (int64)v);
+}
+
+const sc_signed &
+sc_signed::operator <<= (const sc_int_base &v)
+{
+    return operator <<= ((int64)v);
+}
+
+
+sc_signed
+operator >> (const sc_signed &u, const sc_int_base &v)
+{
+    return operator >> (u, (int64)v);
+}
+
+const sc_signed &
+sc_signed::operator >>= (const sc_int_base &v)
+{
+    return operator >>= ((int64)v);
+}
+
+
+bool
+operator == (const sc_signed &u, const sc_int_base &v)
+{
+    return operator == (u, (int64)v);
+}
+
+bool
+operator == (const sc_int_base &u, const sc_signed &v)
+{
+    return operator == ((int64)u, v);
+}
+
+
+bool
+operator != (const sc_signed &u, const sc_int_base &v)
+{
+    return operator != (u, (int64)v);
+}
+
+bool
+operator != (const sc_int_base &u, const sc_signed &v)
+{
+    return operator != ((int64)u, v);
+}
+
+
+bool
+operator < (const sc_signed &u, const sc_int_base &v)
+{
+    return operator < (u, (int64)v);
+}
+
+bool
+operator  <  (const sc_int_base &u, const sc_signed &v)
+{
+    return operator < ((int64)u, v);
+}
+
+
+bool
+operator  <=  (const sc_signed &u, const sc_int_base &v)
+{
+    return operator <= (u, (int64)v);
+}
+
+bool
+operator  <=  (const sc_int_base &u, const sc_signed &v)
+{
+    return operator <= ((int64)u, v);
+}
+
+
+bool
+operator  >  (const sc_signed &u, const sc_int_base &v)
+{
+    return operator > (u, (int64)v);
+}
+
+bool
+operator  >  (const sc_int_base &u, const sc_signed &v)
+{
+    return operator > ((int64)u, v);
+}
+
+
+bool
+operator  >=  (const sc_signed &u, const sc_int_base &v)
+{
+    return operator >= (u, (int64)v);
+}
+
+bool
+operator  >=  (const sc_int_base &u, const sc_signed &v)
+{
+    return operator >= ((int64)u, v);
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Interfacing with sc_uint_base
+// ----------------------------------------------------------------------------
+
+const sc_signed &
+sc_signed::operator = (const sc_uint_base &v)
+{
+    return operator = ((uint64)v);
+}
+
+
+sc_signed
+operator + (const sc_signed &u, const sc_uint_base &v)
+{
+    return operator + (u, (uint64)v);
+}
+
+sc_signed
+operator + (const sc_uint_base &u, const sc_signed &v)
+{
+    return operator + ((uint64)u, v);
+}
+
+const sc_signed &
+sc_signed::operator += (const sc_uint_base &v)
+{
+    return operator += ((uint64)v);
+}
+
+
+sc_signed
+operator - (const sc_unsigned &u, const sc_uint_base &v)
+{
+    return operator - (u, (uint64)v);
+}
+
+sc_signed
+operator - (const sc_uint_base &u, const sc_unsigned &v)
+{
+    return operator - ((uint64)u, v);
+}
+
+sc_signed
+operator - (const sc_signed &u, const sc_uint_base &v)
+{
+    return operator - (u, (uint64)v);
+}
+
+sc_signed
+operator - (const sc_uint_base &u, const sc_signed &v)
+{
+    return operator - ((uint64)u, v);
+}
+
+const sc_signed &
+sc_signed::operator -= (const sc_uint_base &v)
+{
+    return operator -= ((uint64)v);
+}
+
+
+sc_signed
+operator * (const sc_signed &u, const sc_uint_base &v)
+{
+    return operator * (u, (uint64)v);
+}
+
+sc_signed
+operator * (const sc_uint_base &u, const sc_signed &v)
+{
+    return operator * ((uint64)u, v);
+}
+
+const sc_signed &
+sc_signed::operator *= (const sc_uint_base &v)
+{
+    return operator *= ((uint64)v);
+}
+
+
+sc_signed
+operator / (const sc_signed &u, const sc_uint_base &v)
+{
+    return operator / (u, (uint64)v);
+}
+
+sc_signed
+operator / (const sc_uint_base &u, const sc_signed &v)
+{
+    return operator / ((uint64)u, v);
+}
+
+const sc_signed &
+sc_signed::operator /= (const sc_uint_base &v)
+{
+    return operator /= ((uint64)v);
+}
+
+
+sc_signed
+operator % (const sc_signed &u, const sc_uint_base &v)
+{
+    return operator % (u, (uint64)v);
+}
+
+sc_signed
+operator % (const sc_uint_base &u, const sc_signed &v)
+{
+    return operator % ((uint64)u, v);
+}
+
+const sc_signed&
+sc_signed::operator %= (const sc_uint_base &v)
+{
+    return operator %= ((uint64)v);
+}
+
+
+sc_signed
+operator & (const sc_signed &u, const sc_uint_base &v)
+{
+    return operator & (u, (uint64)v);
+}
+
+sc_signed
+operator & (const sc_uint_base &u, const sc_signed &v)
+{
+    return operator & ((uint64)u, v);
+}
+
+const sc_signed &
+sc_signed::operator &= (const sc_uint_base &v)
+{
+    return operator &= ((uint64)v);
+}
+
+
+sc_signed
+operator | (const sc_signed &u, const sc_uint_base &v)
+{
+    return operator | (u, (uint64)v);
+}
+
+sc_signed
+operator | (const sc_uint_base &u, const sc_signed &v)
+{
+    return operator | ((uint64)u, v);
+}
+
+const sc_signed &
+sc_signed::operator |= (const sc_uint_base &v)
+{
+    return operator |= ((uint64)v);
+}
+
+
+sc_signed
+operator ^ (const sc_signed &u, const sc_uint_base &v)
+{
+    return operator ^ (u, (uint64)v);
+}
+
+sc_signed
+operator ^ (const sc_uint_base &u, const sc_signed &v)
+{
+    return operator ^ ((uint64)u, v);
+}
+
+const sc_signed &
+sc_signed::operator ^= (const sc_uint_base &v)
+{
+    return operator ^= ((uint64)v);
+}
+
+
+sc_signed
+operator << (const sc_signed &u, const sc_uint_base &v)
+{
+    return operator << (u, (uint64)v);
+}
+
+const sc_signed &
+sc_signed::operator <<= (const sc_uint_base &v)
+{
+    return operator <<= ((uint64)v);
+}
+
+
+sc_signed
+operator >> (const sc_signed& u, const sc_uint_base& v)
+{
+    return operator >> (u, (uint64)v);
+}
+
+const sc_signed &
+sc_signed::operator >>= (const sc_uint_base& v)
+{
+    return operator >>= ((uint64)v);
+}
+
+
+bool
+operator == (const sc_signed &u, const sc_uint_base &v)
+{
+    return operator == (u, (uint64)v);
+}
+
+bool
+operator == (const sc_uint_base &u, const sc_signed &v)
+{
+    return operator == ((uint64)u, v);
+}
+
+
+bool
+operator != (const sc_signed &u, const sc_uint_base &v)
+{
+    return operator != (u, (uint64)v);
+}
+
+bool
+operator != (const sc_uint_base &u, const sc_signed &v)
+{
+    return operator != ((uint64)u, v);
+}
+
+
+bool
+operator < (const sc_signed &u, const sc_uint_base &v)
+{
+    return operator < (u, (uint64)v);
+}
+
+bool
+operator < (const sc_uint_base &u, const sc_signed &v)
+{
+    return operator < ((uint64)u, v);
+}
+
+
+bool
+operator <= (const sc_signed &u, const sc_uint_base &v)
+{
+    return operator <= (u, (uint64)v);
+}
+
+bool
+operator <= (const sc_uint_base &u, const sc_signed &v)
+{
+    return operator <= ((uint64)u, v);
+}
+
+
+bool
+operator > (const sc_signed &u, const sc_uint_base &v)
+{
+    return operator > (u, (uint64)v);
+}
+
+bool
+operator > (const sc_uint_base &u, const sc_signed &v)
+{
+    return operator > ((uint64)u, v);
+}
+
+
+bool
+operator >= (const sc_signed &u, const sc_uint_base &v)
+{
+    return operator >= (u, (uint64)v);
+}
+
+bool
+operator >= (const sc_uint_base &u, const sc_signed &v)
+{
+    return operator >= ((uint64)u, v);
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Input and output operators
+// ----------------------------------------------------------------------------
+
+// Operators in this section are included from sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Operator macros.
+// ----------------------------------------------------------------------------
+
+#define CONVERT_LONG(u) \
+small_type u ## s = get_sign(u); \
+sc_digit u ## d[DIGITS_PER_ULONG]; \
+from_uint(DIGITS_PER_ULONG, u ## d, (unsigned long) u);
+
+#define CONVERT_LONG_2(u) \
+sc_digit u ## d[DIGITS_PER_ULONG]; \
+from_uint(DIGITS_PER_ULONG, u ## d, (unsigned long) u);
+
+#define CONVERT_INT(u) \
+small_type u ## s = get_sign(u); \
+sc_digit u ## d[DIGITS_PER_UINT]; \
+from_uint(DIGITS_PER_UINT, u ## d, (unsigned int) u);
+
+#define CONVERT_INT_2(u) \
+sc_digit u ## d[DIGITS_PER_UINT]; \
+from_uint(DIGITS_PER_UINT, u ## d, (unsigned int) u);
+
+#define CONVERT_INT64(u) \
+small_type u ## s = get_sign(u); \
+sc_digit u ## d[DIGITS_PER_UINT64]; \
+from_uint(DIGITS_PER_UINT64, u ## d, (uint64) u);
+
+#define CONVERT_INT64_2(u) \
+sc_digit u ## d[DIGITS_PER_UINT64]; \
+from_uint(DIGITS_PER_UINT64, u ## d, (uint64) u);
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: PLUS operators: +, +=, ++
+// ----------------------------------------------------------------------------
+
+// Cases to consider when computing u + v:
+// 1. 0 + v = v
+// 2. u + 0 = u
+// 3. if sgn(u) == sgn(v)
+//    3.1 u + v = +(u + v) = sgn(u) * (u + v)
+//    3.2 (-u) + (-v) = -(u + v) = sgn(u) * (u + v)
+// 4. if sgn(u) != sgn(v)
+//    4.1 u + (-v) = u - v = sgn(u) * (u - v)
+//    4.2 (-u) + v = -(u - v) ==> sgn(u) * (u - v)
+//
+// Specialization of above cases for computing ++u or u++:
+// 1. 0 + 1 = 1
+// 3. u + 1 = u + 1 = sgn(u) * (u + 1)
+// 4. (-u) + 1 = -(u - 1) = sgn(u) * (u - 1)
+
+sc_signed
+operator + (const sc_unsigned &u, const sc_signed &v)
+{
+    if (u.sgn == SC_ZERO) // case 1
+        return sc_signed(v);
+
+    if (v.sgn == SC_ZERO) // case 2
+        return sc_signed(u);
+
+    // cases 3 and 4
+    return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator + (const sc_signed &u, const sc_unsigned &v)
+{
+    if (u.sgn == SC_ZERO) // case 1
+        return sc_signed(v);
+
+    if (v.sgn == SC_ZERO) // case 2
+        return sc_signed(u);
+
+    // cases 3 and 4
+    return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator + (const sc_signed &u, const sc_signed &v)
+{
+    if (u.sgn == SC_ZERO) // case 1
+        return sc_signed(v);
+
+    if (v.sgn == SC_ZERO) // case 2
+        return sc_signed(u);
+
+    // cases 3 and 4
+    return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator + (const sc_signed &u, int64 v)
+{
+    if (v == 0) // case 2
+        return sc_signed(u);
+
+    CONVERT_INT64(v);
+
+    if (u.sgn == SC_ZERO) // case 1
+        return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
+
+    // cases 3 and 4
+    return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+}
+
+
+sc_signed
+operator + (int64 u, const sc_signed &v)
+{
+    if (u == 0) // case 1
+        return sc_signed(v);
+
+    CONVERT_INT64(u);
+
+    if (v.sgn == SC_ZERO) // case 2
+        return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
+
+    // cases 3 and 4
+    return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                             v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator + (const sc_unsigned &u, int64 v)
+{
+    if (v == 0) // case 2
+        return sc_signed(u);
+
+    CONVERT_INT64(v);
+
+    if (u.sgn == SC_ZERO) // case 1
+        return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
+
+    // cases 3 and 4
+    return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+}
+
+
+sc_signed
+operator + (int64 u, const sc_unsigned &v)
+{
+    if (u == 0) // case 1
+        return sc_signed(v);
+
+    CONVERT_INT64(u);
+
+    if (v.sgn == SC_ZERO) // case 2
+        return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
+
+    // cases 3 and 4
+    return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                             v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator + (const sc_signed &u, uint64 v)
+{
+    if (v == 0) // case 2
+        return sc_signed(u);
+
+    CONVERT_INT64(v);
+
+    if (u.sgn == SC_ZERO) // case 1
+        return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
+
+    // cases 3 and 4
+    return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+}
+
+
+sc_signed
+operator + (uint64 u, const sc_signed &v)
+{
+    if (u == 0) // case 1
+        return sc_signed(v);
+
+    CONVERT_INT64(u);
+
+    if (v.sgn == SC_ZERO) // case 2
+        return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
+
+    // cases 3 and 4
+    return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                             v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator + (const sc_signed &u, long v)
+{
+    if (v == 0) // case 2
+        return sc_signed(u);
+
+    CONVERT_LONG(v);
+
+    if (u.sgn == SC_ZERO) // case 1
+        return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
+
+    // cases 3 and 4
+    return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+}
+
+
+sc_signed
+operator + (long u, const sc_signed &v)
+{
+    if (u == 0) // case 1
+        return sc_signed(v);
+
+    CONVERT_LONG(u);
+
+    if (v.sgn == SC_ZERO) // case 2
+        return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
+
+    // cases 3 and 4
+    return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                             v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator + (const sc_unsigned &u, long v)
+{
+    if (v == 0) // case 2
+        return sc_signed(u);
+
+    CONVERT_LONG(v);
+
+    if (u.sgn == SC_ZERO) // case 1
+        return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
+
+    // cases 3 and 4
+    return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+}
+
+
+sc_signed
+operator + (long u, const sc_unsigned &v)
+{
+    if (u == 0) // case 1
+        return sc_signed(v);
+
+    CONVERT_LONG(u);
+
+    if (v.sgn == SC_ZERO) // case 2
+        return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
+
+    // cases 3 and 4
+    return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                             v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator + (const sc_signed &u, unsigned long v)
+{
+    if (v == 0) // case 2
+        return sc_signed(u);
+
+    CONVERT_LONG(v);
+
+    if (u.sgn == SC_ZERO) // case 1
+        return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
+
+    // cases 3 and 4
+    return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+}
+
+
+sc_signed
+operator + (unsigned long u, const sc_signed &v)
+{
+    if (u == 0) // case 1
+        return sc_signed(v);
+
+    CONVERT_LONG(u);
+
+    if (v.sgn == SC_ZERO)  // case 2
+        return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
+
+    // cases 3 and 4
+    return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                             v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+// The rest of the operators in this section are included from
+// sc_nbcommon.cpp.
+
+// ----------------------------------------------------------------------------
+//  SECTION: MINUS operators: -, -=, --
+// ----------------------------------------------------------------------------
+
+// Cases to consider when computing u + v:
+// 1. u - 0 = u
+// 2. 0 - v = -v
+// 3. if sgn(u) != sgn(v)
+//    3.1 u - (-v) = u + v = sgn(u) * (u + v)
+//    3.2 (-u) - v = -(u + v) ==> sgn(u) * (u + v)
+// 4. if sgn(u) == sgn(v)
+//    4.1 u - v = +(u - v) = sgn(u) * (u - v)
+//    4.2 (-u) - (-v) = -(u - v) = sgn(u) * (u - v)
+//
+// Specialization of above cases for computing --u or u--:
+// 1. 0 - 1 = -1
+// 3. (-u) - 1 = -(u + 1) = sgn(u) * (u + 1)
+// 4. u - 1 = u - 1 = sgn(u) * (u - 1)
+
+sc_signed
+operator - (const sc_unsigned &u, const sc_unsigned &v)
+{
+    if (v.sgn == SC_ZERO)  // case 1
+        return sc_signed(u);
+
+    if (u.sgn == SC_ZERO) // case 2
+        return sc_signed(v, -v.sgn);
+
+    // cases 3 and 4
+    return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             -v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator - (const sc_unsigned &u, const sc_signed &v)
+{
+    if (v.sgn == SC_ZERO) // case 1
+        return sc_signed(u);
+
+    if (u.sgn == SC_ZERO) // case 2
+        return sc_signed(v, -v.sgn);
+
+    // cases 3 and 4
+    return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             -v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator - (const sc_signed &u, const sc_unsigned &v)
+{
+    if (v.sgn == SC_ZERO) // case 1
+        return sc_signed(u);
+
+    if (u.sgn == SC_ZERO) // case 2
+        return sc_signed(v, -v.sgn);
+
+    // cases 3 and 4
+    return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             -v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator - (const sc_signed &u, const sc_signed &v)
+{
+    if (v.sgn == SC_ZERO)  // case 1
+        return sc_signed(u);
+
+    if (u.sgn == SC_ZERO) // case 2
+        return sc_signed(v, -v.sgn);
+
+    // cases 3 and 4
+    return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             -v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator - (const sc_signed &u, int64 v)
+{
+    if (v == 0) // case 1
+        return sc_signed(u);
+
+    CONVERT_INT64(v);
+
+    if (u.sgn == SC_ZERO) // case 2
+        return sc_signed(-vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
+
+    // cases 3 and 4
+    return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             -vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+}
+
+
+sc_signed
+operator - (int64 u, const sc_signed &v)
+{
+    if (u == 0) // case 1
+        return sc_signed(v, -v.sgn);
+
+    CONVERT_INT64(u);
+
+    if (v.sgn == SC_ZERO) // case 2
+        return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
+
+    // cases 3 and 4
+    return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                             -v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator - (const sc_unsigned &u, int64 v)
+{
+    if (v == 0) // case 1
+        return sc_signed(u);
+
+    CONVERT_INT64(v);
+
+    if (u.sgn == SC_ZERO) // case 2
+        return sc_signed(-vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
+
+    // cases 3 and 4
+    return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             -vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+}
+
+
+sc_signed
+operator - (int64 u, const sc_unsigned &v)
+{
+    if (u == 0) // case 1
+        return sc_signed(v, -v.sgn);
+
+    CONVERT_INT64(u);
+
+    if (v.sgn == SC_ZERO) // case 2
+        return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
+
+    // cases 3 and 4
+    return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                             -v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator - (const sc_signed &u, uint64 v)
+{
+    if (v == 0) // case 1
+        return sc_signed(u);
+
+    CONVERT_INT64(v);
+
+    if (u.sgn == SC_ZERO) // case 2
+        return sc_signed(-vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
+
+    // cases 3 and 4
+
+    return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             -vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+}
+
+
+sc_signed
+operator - (uint64 u, const sc_signed &v)
+{
+    if (u == 0) // case 1
+        return sc_signed(v, -v.sgn);
+
+    CONVERT_INT64(u);
+
+    if (v.sgn == SC_ZERO) // case 2
+        return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
+
+    // cases 3 and 4
+    return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                             -v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator - (const sc_unsigned &u, uint64 v)
+{
+    if (v == 0) // case 1
+        return sc_signed(u);
+
+    CONVERT_INT64(v);
+
+    if (u.sgn == SC_ZERO) // case 2
+        return sc_signed(-vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
+
+    // cases 3 and 4
+    return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             -vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+}
+
+
+sc_signed
+operator - (uint64 u, const sc_unsigned &v)
+{
+    if (u == 0) // case 1
+        return sc_signed(v, -v.sgn);
+
+    CONVERT_INT64(u);
+
+    if (v.sgn == SC_ZERO) // case 2
+        return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
+
+    // cases 3 and 4
+    return add_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                             -v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator - (const sc_signed &u, long v)
+{
+    if (v == 0) // case 1
+        return sc_signed(u);
+
+    CONVERT_LONG(v);
+
+    if (u.sgn == SC_ZERO) // case 2
+        return sc_signed(-vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
+
+    // cases 3 and 4
+    return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             -vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+}
+
+
+sc_signed
+operator - (long u, const sc_signed &v)
+{
+    if (u == 0) // case 1
+        return sc_signed(v, -v.sgn);
+
+    CONVERT_LONG(u);
+
+    if (v.sgn == SC_ZERO) // case 2
+        return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
+
+    // cases 3 and 4
+    return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                             -v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator - (const sc_unsigned &u, long v)
+{
+    if (v == 0) // case 1
+        return sc_signed(u);
+
+    CONVERT_LONG(v);
+
+    if (u.sgn == SC_ZERO) // case 2
+        return sc_signed(-vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
+
+    // cases 3 and 4
+    return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             -vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+}
+
+
+sc_signed
+operator - (long u, const sc_unsigned &v)
+{
+    if (u == 0) // case 1
+        return sc_signed(v, -v.sgn);
+
+    CONVERT_LONG(u);
+
+    if (v.sgn == SC_ZERO) // case 2
+        return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
+
+    // cases 3 and 4
+    return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                             -v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator - (const sc_signed &u, unsigned long v)
+{
+    if (v == 0) // case 1
+        return sc_signed(u);
+
+    CONVERT_LONG(v);
+
+    if (u.sgn == SC_ZERO) // case 2
+        return sc_signed(-vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
+
+    // cases 3 and 4
+    return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             -vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+}
+
+
+sc_signed
+operator - (unsigned long u, const sc_signed &v)
+{
+    if (u == 0) // case 1
+        return sc_signed(v, -v.sgn);
+
+    CONVERT_LONG(u);
+
+    if (v.sgn == SC_ZERO) // case 2
+        return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
+
+    // cases 3 and 4
+    return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                             -v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator - (const sc_unsigned &u, unsigned long v)
+{
+    if (v == 0) // case 1
+        return sc_signed(u);
+
+    CONVERT_LONG(v);
+
+    if (u.sgn == SC_ZERO) // case 2
+        return sc_signed(-vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
+
+    // cases 3 and 4
+    return add_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             -vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+}
+
+
+sc_signed
+operator - (unsigned long u, const sc_unsigned &v)
+{
+    if (u == 0) // case 1
+        return sc_signed(v, -v.sgn);
+
+    CONVERT_LONG(u);
+
+    if (v.sgn == SC_ZERO) // case 2
+        return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
+
+    // cases 3 and 4
+    return add_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                             -v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+// The rest of the operators in this section are included from
+// sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: MULTIPLICATION operators: *, *=
+// ----------------------------------------------------------------------------
+
+// Cases to consider when computing u * v:
+// 1. u * 0 = 0 * v = 0
+// 2. 1 * v = v and -1 * v = -v
+// 3. u * 1 = u and u * -1 = -u
+// 4. u * v = u * v
+
+sc_signed
+operator * (const sc_unsigned &u, const sc_signed &v)
+{
+    small_type s = mul_signs(u.sgn, v.sgn);
+
+    if (s == SC_ZERO) // case 1
+        return sc_signed();
+
+    // cases 2-4
+    return mul_signed_friend(s, u.nbits, u.ndigits, u.digit,
+                             v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator * (const sc_signed &u, const sc_unsigned &v)
+{
+    small_type s = mul_signs(u.sgn, v.sgn);
+
+    if (s == SC_ZERO) // case 1
+        return sc_signed();
+
+    // cases 2-4
+    return mul_signed_friend(s, u.nbits, u.ndigits, u.digit,
+                             v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator * (const sc_signed &u, const sc_signed &v)
+{
+    small_type s = mul_signs(u.sgn, v.sgn);
+
+    if (s == SC_ZERO) // case 1
+        return sc_signed();
+
+    // cases 2-4
+    return mul_signed_friend(s, u.nbits, u.ndigits, u.digit,
+                             v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator * (const sc_signed &u, int64 v)
+{
+    small_type s = mul_signs(u.sgn, get_sign(v));
+
+    if (s == SC_ZERO) // case 1
+        return sc_signed();
+
+    CONVERT_INT64_2(v);
+
+    // cases 2-4
+    return mul_signed_friend(s, u.nbits, u.ndigits, u.digit,
+                             BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+}
+
+
+sc_signed
+operator * (int64 u, const sc_signed &v)
+{
+    small_type s = mul_signs(v.sgn, get_sign(u));
+
+    if (s == SC_ZERO) // case 1
+        return sc_signed();
+
+    CONVERT_INT64_2(u);
+
+    // cases 2-4
+    return mul_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                             v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator * (const sc_unsigned &u, int64 v)
+{
+    small_type s = mul_signs(u.sgn, get_sign(v));
+
+    if (s == SC_ZERO) // case 1
+        return sc_signed();
+
+    CONVERT_INT64_2(v);
+
+    // cases 2-4
+    return mul_signed_friend(s, u.nbits, u.ndigits, u.digit,
+                             BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+}
+
+
+sc_signed
+operator * (int64 u, const sc_unsigned &v)
+{
+    small_type s = mul_signs(v.sgn, get_sign(u));
+
+    if (s == SC_ZERO) // case 1
+        return sc_signed();
+
+    CONVERT_INT64_2(u);
+
+    // cases 2-4
+    return mul_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                             v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator * (const sc_signed &u, uint64 v)
+{
+    small_type s = mul_signs(u.sgn, get_sign(v));
+
+    if (s == SC_ZERO) // case 1
+        return sc_signed();
+
+    CONVERT_INT64_2(v);
+
+    // cases 2-4
+    return mul_signed_friend(s, u.nbits, u.ndigits, u.digit,
+                             BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+}
+
+
+sc_signed
+operator * (uint64 u, const sc_signed &v)
+{
+    small_type s = mul_signs(v.sgn, get_sign(u));
+
+    if (s == SC_ZERO) // case 1
+        return sc_signed();
+
+    CONVERT_INT64_2(u);
+
+    // cases 2-4
+    return mul_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                             v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator * (const sc_signed &u, long v)
+{
+    small_type s = mul_signs(u.sgn, get_sign(v));
+
+    if (s == SC_ZERO) // case 1
+        return sc_signed();
+
+    CONVERT_LONG_2(v);
+
+    // cases 2-4
+    return mul_signed_friend(s, u.nbits, u.ndigits, u.digit,
+                             BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+}
+
+
+sc_signed
+operator * (long u, const sc_signed &v)
+{
+    small_type s = mul_signs(v.sgn, get_sign(u));
+
+    if (s == SC_ZERO) // case 1
+        return sc_signed();
+
+    CONVERT_LONG_2(u);
+
+    // cases 2-4
+    return mul_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                             v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator * (const sc_unsigned &u, long v)
+{
+    small_type s = mul_signs(u.sgn, get_sign(v));
+
+    if (s == SC_ZERO) // case 1
+        return sc_signed();
+
+    CONVERT_LONG_2(v);
+
+    // cases 2-4
+    return mul_signed_friend(s, u.nbits, u.ndigits, u.digit,
+                             BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+}
+
+
+sc_signed
+operator * (long u, const sc_unsigned &v)
+{
+    small_type s = mul_signs(v.sgn, get_sign(u));
+
+    if (s == SC_ZERO) // case 1
+        return sc_signed();
+
+    CONVERT_LONG_2(u);
+
+    // cases 2-4
+    return mul_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                             v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator * (const sc_signed &u, unsigned long v)
+{
+    small_type s = mul_signs(u.sgn, get_sign(v));
+
+    if (s == SC_ZERO) // case 1
+        return sc_signed();
+
+    CONVERT_LONG_2(v);
+
+    // else cases 2-4
+    return mul_signed_friend(s, u.nbits, u.ndigits, u.digit,
+                             BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+}
+
+sc_signed
+operator * (unsigned long u, const sc_signed &v)
+{
+    small_type s = mul_signs(v.sgn, get_sign(u));
+
+    if (s == SC_ZERO) // case 1
+        return sc_signed();
+
+    CONVERT_LONG_2(u);
+
+    // cases 2-4
+    return mul_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                             v.nbits, v.ndigits, v.digit);
+}
+
+// The rest of the operators in this section are included from
+// sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: DIVISION operators: /, /=
+// ----------------------------------------------------------------------------
+
+// Cases to consider when finding the quotient q = floor(u/v):
+// Note that u = q * v + r for r < q.
+// 1. 0 / 0 or u / 0 => error
+// 2. 0 / v => 0 = 0 * v + 0
+// 3. u / v & &u = v => u = 1 * u + 0  - u or v can be 1 or -1
+// 4. u / v & &u < v => u = 0 * v + u  - u can be 1 or -1
+// 5. u / v & &u > v => u = q * v + r  - v can be 1 or -1
+
+sc_signed
+operator / (const sc_unsigned &u, const sc_signed &v)
+{
+    small_type s = mul_signs(u.sgn, v.sgn);
+
+    if (s == SC_ZERO) {
+        div_by_zero(v.sgn); // case 1
+        return sc_signed(); // case 2
+    }
+
+    // other cases
+    return div_signed_friend(s, u.nbits, u.ndigits, u.digit,
+                             v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator / (const sc_signed &u, const sc_unsigned &v)
+{
+    small_type s = mul_signs(u.sgn, v.sgn);
+
+    if (s == SC_ZERO) {
+        div_by_zero(v.sgn); // case 1
+        return sc_signed(); // case 2
+    }
+
+    // other cases
+    return div_signed_friend(s, u.nbits, u.ndigits, u.digit,
+                             v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator / (const sc_signed &u, const sc_signed &v)
+{
+    small_type s = mul_signs(u.sgn, v.sgn);
+
+    if (s == SC_ZERO) {
+        div_by_zero(v.sgn); // case 1
+        return sc_signed(); // case 2
+    }
+
+    // other cases
+    return div_signed_friend(s, u.nbits, u.ndigits, u.digit,
+                             v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator / (const sc_signed &u, int64 v)
+{
+    small_type s = mul_signs(u.sgn, get_sign(v));
+
+    if (s == SC_ZERO) {
+        div_by_zero(v); // case 1
+        return sc_signed(); // case 2
+    }
+
+    CONVERT_INT64_2(v);
+
+    // other cases
+    return div_signed_friend(s, u.nbits, u.ndigits, u.digit,
+                             BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+}
+
+
+sc_signed
+operator / (int64 u, const sc_signed &v)
+{
+    small_type s = mul_signs(v.sgn, get_sign(u));
+
+    if (s == SC_ZERO) {
+        div_by_zero(v.sgn); // case 1
+        return sc_signed(); // case 2
+    }
+
+    CONVERT_INT64_2(u);
+
+    // other cases
+    return div_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                             v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator / (const sc_unsigned &u, int64 v)
+{
+    small_type s = mul_signs(u.sgn, get_sign(v));
+
+    if (s == SC_ZERO) {
+        div_by_zero(v); // case 1
+        return sc_signed(); // case 2
+    }
+
+    CONVERT_INT64_2(v);
+
+    // other cases
+    return div_signed_friend(s, u.nbits, u.ndigits, u.digit,
+                             BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+}
+
+
+sc_signed
+operator / (int64 u, const sc_unsigned &v)
+{
+    small_type s = mul_signs(v.sgn, get_sign(u));
+
+    if (s == SC_ZERO) {
+        div_by_zero(v.sgn); // case 1
+        return sc_signed(); // case 2
+    }
+
+    CONVERT_INT64_2(u);
+
+    // other cases
+    return div_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                             v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator / (const sc_signed &u, uint64 v)
+{
+    small_type s = mul_signs(u.sgn, get_sign(v));
+
+    if (s == SC_ZERO) {
+        div_by_zero(v); // case 1
+        return sc_signed(); // case 2
+    }
+
+    CONVERT_INT64_2(v);
+
+    // other cases
+    return div_signed_friend(s, u.nbits, u.ndigits, u.digit,
+                             BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+}
+
+
+sc_signed
+operator / (uint64 u, const sc_signed &v)
+{
+    small_type s = mul_signs(v.sgn, get_sign(u));
+
+    if (s == SC_ZERO) {
+        div_by_zero(v.sgn); // case 1
+        return sc_signed(); // case 2
+
+    }
+
+    CONVERT_INT64_2(u);
+
+    // other cases
+    return div_signed_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                             v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator / (const sc_signed &u, long v)
+{
+    small_type s = mul_signs(u.sgn, get_sign(v));
+
+    if (s == SC_ZERO) {
+        div_by_zero(v); // case 1
+        return sc_signed(); // case 2
+    }
+
+    CONVERT_LONG_2(v);
+
+    // other cases
+    return div_signed_friend(s, u.nbits, u.ndigits, u.digit,
+                             BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+}
+
+
+sc_signed
+operator / (long u, const sc_signed &v)
+{
+    small_type s = mul_signs(v.sgn, get_sign(u));
+
+    if (s == SC_ZERO) {
+        div_by_zero(v.sgn); // case 1
+        return sc_signed(); // case 2
+    }
+
+    CONVERT_LONG_2(u);
+
+    // other cases
+    return div_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                             v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator / (const sc_unsigned &u, long v)
+{
+    small_type s = mul_signs(u.sgn, get_sign(v));
+
+    if (s == SC_ZERO) {
+        div_by_zero(v); // case 1
+        return sc_signed(); // case 2
+    }
+
+    CONVERT_LONG_2(v);
+
+    // other cases
+    return div_signed_friend(s, u.nbits, u.ndigits, u.digit,
+                             BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+}
+
+
+sc_signed
+operator / (long u, const sc_unsigned &v)
+{
+    small_type s = mul_signs(v.sgn, get_sign(u));
+
+    if (s == SC_ZERO) {
+        div_by_zero(v.sgn); // case 1
+        return sc_signed(); // case 2
+    }
+
+    CONVERT_LONG_2(u);
+
+    // other cases
+    return div_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                             v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator / (const sc_signed &u, unsigned long v)
+{
+    small_type s = mul_signs(u.sgn, get_sign(v));
+
+    if (s == SC_ZERO) {
+        div_by_zero(v); // case 1
+        return sc_signed(); // case 2
+    }
+
+    CONVERT_LONG_2(v);
+
+    // other cases
+    return div_signed_friend(s, u.nbits, u.ndigits, u.digit,
+                             BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+}
+
+
+sc_signed
+operator / (unsigned long u, const sc_signed &v)
+{
+    small_type s = mul_signs(v.sgn, get_sign(u));
+
+    if (s == SC_ZERO) {
+        div_by_zero(v.sgn); // case 1
+        return sc_signed(); // case 2
+
+    }
+
+    CONVERT_LONG_2(u);
+
+    // other cases
+    return div_signed_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                             v.nbits, v.ndigits, v.digit);
+}
+
+// The rest of the operators in this section are included from
+// sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: MOD operators: %, %=.
+// ----------------------------------------------------------------------------
+
+// Cases to consider when finding the remainder r = u % v:
+// Note that u = q * v + r for r < q.
+// 1. 0 % 0 or u % 0 => error
+// 2. 0 % v => 0 = 0 * v + 0
+// 3. u % v & &u = v => u = 1 * u + 0  - u or v can be 1 or -1
+// 4. u % v & &u < v => u = 0 * v + u  - u can be 1 or -1
+// 5. u % v & &u > v => u = q * v + r  - v can be 1 or -1
+
+sc_signed
+operator % (const sc_unsigned &u, const sc_signed &v)
+{
+    if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) {
+        div_by_zero(v.sgn); // case 1
+        return sc_signed(); // case 2
+    }
+
+    // other cases
+    return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator % (const sc_signed &u, const sc_unsigned &v)
+{
+    if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) {
+        div_by_zero(v.sgn); // case 1
+        return sc_signed(); // case 2
+    }
+
+    // other cases
+    return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator % (const sc_signed &u, const sc_signed &v)
+{
+    if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) {
+        div_by_zero(v.sgn); // case 1
+        return sc_signed(); // case 2
+    }
+
+    // other cases
+    return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator % (const sc_signed &u, int64 v)
+{
+    small_type vs = get_sign(v);
+
+    if ((u.sgn == SC_ZERO) || (vs == SC_ZERO)) {
+        div_by_zero(v); // case 1
+        return sc_signed(); // case 2
+    }
+
+    CONVERT_INT64_2(v);
+
+    // other cases
+    return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+}
+
+
+sc_signed
+operator % (int64 u, const sc_signed &v)
+{
+    small_type us = get_sign(u);
+
+    if ((us == SC_ZERO) || (v.sgn == SC_ZERO)) {
+        div_by_zero(v.sgn); // case 1
+        return sc_signed(); // case 2
+    }
+
+    CONVERT_INT64_2(u);
+
+    // other cases
+    return mod_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                             v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator % (const sc_unsigned &u, int64 v)
+{
+    small_type vs = get_sign(v);
+
+    if ((u.sgn == SC_ZERO) || (vs == SC_ZERO)) {
+        div_by_zero(v); // case 1
+        return sc_signed(); // case 2
+    }
+
+    CONVERT_INT64_2(v);
+
+    // other cases
+    return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+}
+
+
+sc_signed
+operator % (int64 u, const sc_unsigned &v)
+{
+    small_type us = get_sign(u);
+
+    if ((us == SC_ZERO) || (v.sgn == SC_ZERO)) {
+        div_by_zero(v.sgn); // case 1
+        return sc_signed(); // case 2
+    }
+
+    CONVERT_INT64_2(u);
+
+    // other cases
+    return mod_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                             v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator % (const sc_signed &u, uint64 v)
+{
+    if ((u.sgn == SC_ZERO) || (v == 0)) {
+        div_by_zero(v); // case 1
+        return sc_signed(); // case 2
+    }
+
+    CONVERT_INT64_2(v);
+
+    // other cases
+    return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+}
+
+
+sc_signed
+operator % (uint64 u, const sc_signed &v)
+{
+    if ((u == 0) || (v.sgn == SC_ZERO)) {
+        div_by_zero(v.sgn); // case 1
+        return sc_signed(); // case 2
+    }
+
+    CONVERT_INT64(u);
+
+    // other cases
+    return mod_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                             v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator % (const sc_signed &u, long v)
+{
+    small_type vs = get_sign(v);
+
+    if ((u.sgn == SC_ZERO) || (vs == SC_ZERO)) {
+        div_by_zero(v); // case 1
+        return sc_signed(); // case 2
+    }
+
+    CONVERT_LONG_2(v);
+
+    // other cases
+    return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+}
+
+
+sc_signed
+operator % (long u, const sc_signed &v)
+{
+    small_type us = get_sign(u);
+
+    if ((us == SC_ZERO) || (v.sgn == SC_ZERO)) {
+        div_by_zero(v.sgn); // case 1
+        return sc_signed(); // case 2
+    }
+
+    CONVERT_LONG_2(u);
+
+    // other cases
+    return mod_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                             v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator % (const sc_unsigned &u, long v)
+{
+
+  small_type vs = get_sign(v);
+
+  if ((u.sgn == SC_ZERO) || (vs == SC_ZERO)) {
+    div_by_zero(v); // case 1
+    return sc_signed(); // case 2
+  }
+
+  CONVERT_LONG_2(v);
+
+  // other cases
+  return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+}
+
+
+sc_signed
+operator % (long u, const sc_unsigned &v)
+{
+    small_type us = get_sign(u);
+
+    if ((us == SC_ZERO) || (v.sgn == SC_ZERO)) {
+        div_by_zero(v.sgn); // case 1
+        return sc_signed(); // case 2
+    }
+
+    CONVERT_LONG_2(u);
+
+    // other cases
+    return mod_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                             v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator % (const sc_signed &u, unsigned long v)
+{
+    if ((u.sgn == SC_ZERO) || (v == 0)) {
+        div_by_zero(v); // case 1
+        return sc_signed(); // case 2
+    }
+
+    CONVERT_LONG_2(v);
+
+    // other cases
+    return mod_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+}
+
+
+sc_signed
+operator % (unsigned long u, const sc_signed &v)
+{
+    if ((u == 0) || (v.sgn == SC_ZERO)) {
+        div_by_zero(v.sgn); // case 1
+        return sc_signed(); // case 2
+    }
+
+    CONVERT_LONG(u);
+
+    // other cases
+    return mod_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                             v.nbits, v.ndigits, v.digit);
+}
+
+// The rest of the operators in this section are included from
+// sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Bitwise AND operators: &, &=
+// ----------------------------------------------------------------------------
+
+// Cases to consider when computing u  &v:
+// 1. u & 0 = 0  &v = 0
+// 2. u  &v => sgn = +
+// 3. (-u) & (-v) => sgn = -
+// 4. u & (-v) => sgn = +
+// 5. (-u)  &v => sgn = +
+
+sc_signed
+operator & (const sc_unsigned &u, const sc_signed &v)
+{
+    if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) // case 1
+        return sc_signed();
+
+    // other cases
+    return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator & (const sc_signed &u, const sc_unsigned &v)
+{
+    if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) // case 1
+        return sc_signed();
+
+    // other cases
+    return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator & (const sc_signed &u, const sc_signed &v)
+{
+    if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) // case 1
+        return sc_signed();
+
+    // other cases
+    return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator & (const sc_signed &u, int64 v)
+{
+    if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
+        return sc_signed();
+
+    CONVERT_INT64(v);
+
+    // other cases
+    return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+}
+
+
+sc_signed
+operator & (int64 u, const sc_signed &v)
+{
+    if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
+        return sc_signed();
+
+    CONVERT_INT64(u);
+
+    // other cases
+    return and_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                             v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator & (const sc_unsigned &u, int64 v)
+{
+    if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
+        return sc_signed();
+
+    CONVERT_INT64(v);
+
+    // other cases
+    return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+}
+
+
+sc_signed
+operator & (int64 u, const sc_unsigned &v)
+{
+    if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
+        return sc_signed();
+
+    CONVERT_INT64(u);
+
+    // other cases
+    return and_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                             v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator & (const sc_signed &u, uint64 v)
+{
+    if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
+        return sc_signed();
+
+    CONVERT_INT64(v);
+
+    // other cases
+    return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+}
+
+
+sc_signed
+operator & (uint64 u, const sc_signed &v)
+{
+    if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
+        return sc_signed();
+
+    CONVERT_INT64(u);
+
+    // other cases
+    return and_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                             v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator & (const sc_signed &u, long v)
+{
+    if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
+        return sc_signed();
+
+    CONVERT_LONG(v);
+
+    // other cases
+    return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+}
+
+
+sc_signed
+operator & (long u, const sc_signed &v)
+{
+    if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
+        return sc_signed();
+
+    CONVERT_LONG(u);
+
+    // other cases
+    return and_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                             v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator & (const sc_unsigned &u, long v)
+{
+    if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
+        return sc_signed();
+
+    CONVERT_LONG(v);
+
+    // other cases
+    return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+}
+
+
+sc_signed
+operator & (long u, const sc_unsigned &v)
+{
+    if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
+        return sc_signed();
+
+    CONVERT_LONG(u);
+
+    // other cases
+    return and_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                             v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator & (const sc_signed &u, unsigned long v)
+{
+    if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
+        return sc_signed();
+
+    CONVERT_LONG(v);
+
+    // other cases
+    return and_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+}
+
+
+sc_signed
+operator & (unsigned long u, const sc_signed &v)
+{
+    if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
+        return sc_signed();
+
+    CONVERT_LONG(u);
+
+    // other cases
+    return and_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                             v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+// The rest of the operators in this section are included from
+// sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Bitwise OR operators: |, |=
+// ----------------------------------------------------------------------------
+
+// Cases to consider when computing u | v:
+// 1. u | 0 = u
+// 2. 0 | v = v
+// 3. u | v => sgn = +
+// 4. (-u) | (-v) => sgn = -
+// 5. u | (-v) => sgn = -
+// 6. (-u) | v => sgn = -
+
+sc_signed
+operator | (const sc_unsigned &u, const sc_signed &v)
+{
+    if (v.sgn == SC_ZERO) // case 1
+        return sc_signed(u);
+
+    if (u.sgn == SC_ZERO) // case 2
+        return sc_signed(v);
+
+    // other cases
+    return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                            v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator | (const sc_signed &u, const sc_unsigned &v)
+{
+    if (v.sgn == SC_ZERO) // case 1
+        return sc_signed(u);
+
+    if (u.sgn == SC_ZERO) // case 2
+        return sc_signed(v);
+
+    // other cases
+    return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                            v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator | (const sc_signed &u, const sc_signed &v)
+{
+    if (v.sgn == SC_ZERO) // case 1
+        return sc_signed(u);
+
+    if (u.sgn == SC_ZERO) // case 2
+        return sc_signed(v);
+
+    // other cases
+    return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                            v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator | (const sc_signed &u, int64 v)
+{
+    if (v == 0) // case 1
+        return sc_signed(u);
+
+    CONVERT_INT64(v);
+
+    if (u.sgn == SC_ZERO) // case 2
+        return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
+
+    // other cases
+    return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                            vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+}
+
+
+sc_signed
+operator | (int64 u, const sc_signed &v)
+{
+    if (u == 0)
+        return sc_signed(v);
+
+    CONVERT_INT64(u);
+
+    if (v.sgn == SC_ZERO)
+        return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
+
+    // other cases
+    return or_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                            v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator | (const sc_unsigned &u, int64 v)
+{
+    if (v == 0) // case 1
+        return sc_signed(u);
+
+    CONVERT_INT64(v);
+
+    if (u.sgn == SC_ZERO) // case 2
+        return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
+
+    // other cases
+    return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                            vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+}
+
+
+sc_signed
+operator | (int64 u, const sc_unsigned &v)
+{
+    if (u == 0)
+        return sc_signed(v);
+
+    CONVERT_INT64(u);
+
+    if (v.sgn == SC_ZERO)
+        return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
+
+    // other cases
+    return or_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                            v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator | (const sc_signed &u, uint64 v)
+{
+    if (v == 0) // case 1
+        return sc_signed(u);
+
+    CONVERT_INT64(v);
+
+    if (u.sgn == SC_ZERO) // case 2
+        return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
+
+    // other cases
+    return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                            vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+}
+
+
+sc_signed
+operator | (uint64 u, const sc_signed &v)
+{
+    if (u == 0)
+        return sc_signed(v);
+
+    CONVERT_INT64(u);
+
+    if (v.sgn == SC_ZERO)
+        return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
+
+    // other cases
+    return or_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                            v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator | (const sc_signed &u, long v)
+{
+    if (v == 0) // case 1
+        return sc_signed(u);
+
+    CONVERT_LONG(v);
+
+    if (u.sgn == SC_ZERO) // case 2
+        return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
+
+    // other cases
+    return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                            vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+}
+
+
+sc_signed
+operator | (long u, const sc_signed &v)
+{
+    if (u == 0)
+        return sc_signed(v);
+
+    CONVERT_LONG(u);
+
+    if (v.sgn == SC_ZERO)
+        return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
+
+    // other cases
+    return or_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                            v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator | (const sc_unsigned &u, long v)
+{
+    if (v == 0) // case 1
+        return sc_signed(u);
+
+    CONVERT_LONG(v);
+
+    if (u.sgn == SC_ZERO) // case 2
+        return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
+
+    // other cases
+    return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                            vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+}
+
+
+sc_signed
+operator | (long u, const sc_unsigned &v)
+{
+    if (u == 0)
+        return sc_signed(v);
+
+    CONVERT_LONG(u);
+
+    if (v.sgn == SC_ZERO)
+        return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
+
+    // other cases
+    return or_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                            v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator | (const sc_signed &u, unsigned long v)
+{
+    if (v == 0) // case 1
+        return sc_signed(u);
+
+    CONVERT_LONG(v);
+
+    if (u.sgn == SC_ZERO) // case 2
+        return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
+
+    // other cases
+    return or_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                            vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+}
+
+
+sc_signed
+operator | (unsigned long u, const sc_signed &v)
+{
+    if (u == 0)
+        return sc_signed(v);
+
+    CONVERT_LONG(u);
+
+    if (v.sgn == SC_ZERO)
+        return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
+
+    // other cases
+    return or_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                            v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+// The rest of the operators in this section are included from
+// sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Bitwise XOR operators: ^, ^=
+// ----------------------------------------------------------------------------
+
+// Cases to consider when computing u ^ v:
+// Note that  u ^ v = (~u  &v) | (u & ~v).
+// 1. u ^ 0 = u
+// 2. 0 ^ v = v
+// 3. u ^ v => sgn = +
+// 4. (-u) ^ (-v) => sgn = -
+// 5. u ^ (-v) => sgn = -
+// 6. (-u) ^ v => sgn = +
+
+sc_signed
+operator ^ (const sc_unsigned &u, const sc_signed &v)
+{
+
+  if (v.sgn == SC_ZERO) // case 1
+    return sc_signed(u);
+
+  if (u.sgn == SC_ZERO) // case 2
+    return sc_signed(v);
+
+  // other cases
+  return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                           v.sgn, v.nbits, v.ndigits, v.digit);
+
+}
+
+
+sc_signed
+operator ^ (const sc_signed &u, const sc_unsigned &v)
+{
+    if (v.sgn == SC_ZERO) // case 1
+        return sc_signed(u);
+
+    if (u.sgn == SC_ZERO) // case 2
+        return sc_signed(v);
+
+    // other cases
+    return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator ^ (const sc_signed &u, const sc_signed &v)
+{
+    if (v.sgn == SC_ZERO) // case 1
+        return sc_signed(u);
+
+    if (u.sgn == SC_ZERO) // case 2
+        return sc_signed(v);
+
+    // other cases
+    return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator ^ (const sc_signed &u, int64 v)
+{
+    if (v == 0) // case 1
+        return sc_signed(u);
+
+    CONVERT_INT64(v);
+
+    if (u.sgn == SC_ZERO) // case 2
+        return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
+
+    // other cases
+    return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+}
+
+
+sc_signed
+operator ^ (int64 u, const sc_signed &v)
+{
+    if (u == 0)
+        return sc_signed(v);
+
+    CONVERT_INT64(u);
+
+    if (v.sgn == SC_ZERO)
+        return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
+
+    // other cases
+    return xor_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                             v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator ^ (const sc_unsigned &u, int64 v)
+{
+    if (v == 0) // case 1
+        return sc_signed(u);
+
+    CONVERT_INT64(v);
+
+    if (u.sgn == SC_ZERO) // case 2
+        return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
+
+    // other cases
+    return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+}
+
+
+sc_signed
+operator ^ (int64 u, const sc_unsigned &v)
+{
+    if (u == 0)
+        return sc_signed(v);
+
+    CONVERT_INT64(u);
+
+    if (v.sgn == SC_ZERO)
+        return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
+
+    // other cases
+    return xor_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                             v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator ^ (const sc_signed &u, uint64 v)
+{
+    if (v == 0) // case 1
+        return sc_signed(u);
+
+    CONVERT_INT64(v);
+
+    if (u.sgn == SC_ZERO) // case 2
+        return sc_signed(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
+
+    // other cases
+    return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+}
+
+sc_signed
+operator ^ (uint64 u, const sc_signed &v)
+{
+    if (u == 0)
+        return sc_signed(v);
+
+    CONVERT_INT64(u);
+
+    if (v.sgn == SC_ZERO)
+        return sc_signed(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
+
+    // other cases
+    return xor_signed_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                             v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator ^ (const sc_signed &u, long v)
+{
+    if (v == 0) // case 1
+        return sc_signed(u);
+
+    CONVERT_LONG(v);
+
+    if (u.sgn == SC_ZERO) // case 2
+        return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
+
+    // other cases
+    return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+}
+
+
+sc_signed
+operator ^ (long u, const sc_signed &v)
+{
+    if (u == 0)
+        return sc_signed(v);
+
+    CONVERT_LONG(u);
+
+    if (v.sgn == SC_ZERO)
+        return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
+
+    // other cases
+    return xor_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                             v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator ^ (const sc_unsigned &u, long v)
+{
+    if (v == 0) // case 1
+        return sc_signed(u);
+
+    CONVERT_LONG(v);
+
+    if (u.sgn == SC_ZERO) // case 2
+        return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
+
+    // other cases
+    return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+}
+
+
+sc_signed
+operator ^ (long u, const sc_unsigned &v)
+{
+    if (u == 0)
+        return sc_signed(v);
+
+    CONVERT_LONG(u);
+
+    if (v.sgn == SC_ZERO)
+        return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
+
+    // other cases
+    return xor_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                             v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_signed
+operator ^ (const sc_signed &u, unsigned long v)
+{
+    if (v == 0) // case 1
+        return sc_signed(u);
+
+    CONVERT_LONG(v);
+
+    if (u.sgn == SC_ZERO) // case 2
+        return sc_signed(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
+
+    // other cases
+    return xor_signed_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                             vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+}
+
+sc_signed
+operator ^ (unsigned long u, const sc_signed &v)
+{
+    if (u == 0)
+        return sc_signed(v);
+
+    CONVERT_LONG(u);
+
+    if (v.sgn == SC_ZERO)
+        return sc_signed(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
+
+    // other cases
+    return xor_signed_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                             v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+// The rest of the operators in this section are included from
+// sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Bitwise NOT operator: ~
+// ----------------------------------------------------------------------------
+
+// Operators in this section are included from sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: LEFT SHIFT operators: <<, <<=
+// ----------------------------------------------------------------------------
+
+sc_signed
+operator << (const sc_signed &u, const sc_unsigned &v)
+{
+    if (v.sgn == SC_ZERO)
+        return sc_signed(u);
+
+    return operator << (u, v.to_ulong());
+}
+
+// The rest of the operators in this section are included from
+// sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: RIGHT SHIFT operators: >>, >>=
+// ----------------------------------------------------------------------------
+
+sc_signed
+operator >> (const sc_signed &u, const sc_unsigned &v)
+{
+    if (v.sgn == SC_ZERO)
+        return sc_signed(u);
+
+    return operator >> (u, v.to_ulong());
+}
+
+// The rest of the operators in this section are included from
+// sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Unary arithmetic operators.
+// ----------------------------------------------------------------------------
+
+sc_signed
+operator + (const sc_signed &u)
+{
+    return sc_signed(u);
+}
+
+sc_signed
+operator - (const sc_signed &u)
+{
+    return sc_signed(u, -u.sgn);
+}
+
+sc_signed
+operator - (const sc_unsigned &u)
+{
+    return sc_signed(u, -u.sgn);
+}
+
+
+// ----------------------------------------------------------------------------
+//    SECTION: EQUAL operator: ==
+// ----------------------------------------------------------------------------
+
+bool
+operator == (const sc_signed &u, const sc_signed &v)
+{
+    if (u.sgn != v.sgn)
+        return false;
+
+    if (&u == &v)
+        return true;
+
+    if (vec_skip_and_cmp(u.ndigits, u.digit, v.ndigits, v.digit) != 0)
+        return false;
+
+    return true;
+}
+
+
+bool
+operator == (const sc_signed &u, int64 v)
+{
+    CONVERT_INT64(v);
+
+    if (u.sgn != vs)
+        return false;
+
+    if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_INT64, vd) != 0)
+        return false;
+
+    return true;
+}
+
+
+bool
+operator == (int64 u, const sc_signed &v)
+{
+    CONVERT_INT64(u);
+
+    if (us != v.sgn)
+        return false;
+
+    if (vec_skip_and_cmp(DIGITS_PER_INT64, ud, v.ndigits, v.digit) != 0)
+        return false;
+
+    return true;
+}
+
+
+bool
+operator == (const sc_signed &u, uint64 v)
+{
+    CONVERT_INT64(v);
+
+    if (u.sgn != vs)
+        return false;
+
+    if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_INT64, vd) != 0)
+        return false;
+
+    return true;
+}
+
+
+bool
+operator == (uint64 u, const sc_signed &v)
+{
+    CONVERT_INT64(u);
+
+    if (us != v.sgn)
+        return false;
+
+    if (vec_skip_and_cmp(DIGITS_PER_INT64, ud, v.ndigits, v.digit) != 0)
+        return false;
+
+    return true;
+}
+
+
+bool
+operator == (const sc_signed &u, long v)
+{
+    CONVERT_LONG(v);
+
+    if (u.sgn != vs)
+        return false;
+
+    if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_LONG, vd) != 0)
+        return false;
+
+    return true;
+}
+
+
+bool
+operator == (long u, const sc_signed &v)
+{
+    CONVERT_LONG(u);
+
+    if (us != v.sgn)
+        return false;
+
+    if (vec_skip_and_cmp(DIGITS_PER_LONG, ud, v.ndigits, v.digit) != 0)
+        return false;
+
+    return true;
+}
+
+
+bool
+operator == (const sc_signed &u, unsigned long v)
+{
+    CONVERT_LONG(v);
+
+    if (u.sgn != vs)
+        return false;
+
+    if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_LONG, vd) != 0)
+        return false;
+
+    return true;
+}
+
+
+bool
+operator == (unsigned long u, const sc_signed &v)
+{
+    CONVERT_LONG(u);
+
+    if (us != v.sgn)
+        return false;
+
+    if (vec_skip_and_cmp(DIGITS_PER_LONG, ud, v.ndigits, v.digit) != 0)
+        return false;
+
+    return true;
+}
+
+
+// ----------------------------------------------------------------------------
+//    SECTION: NOT_EQUAL operator: !=
+// ----------------------------------------------------------------------------
+
+// Operators in this section are included from sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//    SECTION: LESS THAN operator: <
+// ----------------------------------------------------------------------------
+
+bool
+operator < (const sc_signed &u, const sc_signed &v)
+{
+    if (u.sgn < v.sgn)
+        return true;
+
+    if (u.sgn > v.sgn)
+        return false;
+
+    // u.sgn == v.sgn
+
+    if (&u == &v)
+        return false;
+
+    if (u.sgn == SC_POS) {
+        if (vec_skip_and_cmp(u.ndigits, u.digit, v.ndigits, v.digit) < 0)
+            return true;
+    } else if (u.sgn == SC_NEG) {
+        if (vec_skip_and_cmp(u.ndigits, u.digit, v.ndigits, v.digit) > 0)
+            return true;
+    }
+
+    return false;
+}
+
+
+bool
+operator < (const sc_signed &u, int64 v)
+{
+    CONVERT_INT64(v);
+
+    if (u.sgn < vs)
+        return true;
+
+    if (u.sgn > vs)
+        return false;
+
+    // u.sgn == vs
+
+    if (vs == SC_POS) {
+        if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_INT64, vd) < 0)
+            return true;
+    } else if (vs == SC_NEG) {
+        if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_INT64, vd) > 0)
+            return true;
+    }
+
+    return false;
+}
+
+
+bool
+operator < (int64 u, const sc_signed &v)
+{
+    CONVERT_INT64(u);
+
+    if (us < v.sgn)
+        return true;
+
+    if (us > v.sgn)
+        return false;
+
+    // us == v.sgn
+
+    if (us == SC_POS) {
+        if (vec_skip_and_cmp(DIGITS_PER_INT64, ud, v.ndigits, v.digit) < 0)
+            return true;
+    } else if (us == SC_NEG) {
+        if (vec_skip_and_cmp(DIGITS_PER_INT64, ud, v.ndigits, v.digit) > 0)
+            return true;
+    }
+
+    return false;
+}
+
+
+bool
+operator < (const sc_signed &u, uint64 v)
+{
+    CONVERT_INT64(v);
+
+    if (u.sgn < vs)
+        return true;
+
+    if (u.sgn > vs)
+        return false;
+
+    // u.sgn == vs
+
+    if (vs == SC_POS) {
+        if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_INT64, vd) < 0)
+            return true;
+    }
+
+    return false;
+}
+
+
+bool
+operator < (uint64 u, const sc_signed &v)
+{
+    CONVERT_INT64(u);
+
+    if (us < v.sgn)
+        return true;
+
+    if (us > v.sgn)
+        return false;
+
+    // us == v.sgn
+
+    if (us == SC_POS) {
+        if (vec_skip_and_cmp(DIGITS_PER_INT64, ud, v.ndigits, v.digit) < 0)
+            return true;
+    }
+
+    return false;
+}
+
+
+bool
+operator < (const sc_signed &u, long v)
+{
+    CONVERT_LONG(v);
+
+    if (u.sgn < vs)
+        return true;
+
+    if (u.sgn > vs)
+        return false;
+
+    // u.sgn == vs
+
+    if (vs == SC_POS) {
+        if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_LONG, vd) < 0)
+            return true;
+
+    } else if (vs == SC_NEG) {
+        if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_LONG, vd) > 0)
+            return true;
+    }
+
+    return false;
+}
+
+
+bool
+operator < (long u, const sc_signed &v)
+{
+    CONVERT_LONG(u);
+
+    if (us < v.sgn)
+        return true;
+
+    if (us > v.sgn)
+        return false;
+
+    // us == v.sgn
+
+    if (us == SC_POS) {
+        if (vec_skip_and_cmp(DIGITS_PER_LONG, ud, v.ndigits, v.digit) < 0)
+            return true;
+    } else if (us == SC_NEG) {
+        if (vec_skip_and_cmp(DIGITS_PER_LONG, ud, v.ndigits, v.digit) > 0)
+            return true;
+    }
+
+    return false;
+}
+
+
+bool
+operator < (const sc_signed &u, unsigned long v)
+{
+    CONVERT_LONG(v);
+
+    if (u.sgn < vs)
+        return true;
+
+    if (u.sgn > vs)
+        return false;
+
+    // u.sgn == vs
+
+    if (vs == SC_POS) {
+        if (vec_skip_and_cmp(u.ndigits, u.digit, DIGITS_PER_LONG, vd) < 0)
+            return true;
+    }
+
+    return false;
+}
+
+
+bool
+operator < (unsigned long u, const sc_signed &v)
+{
+    CONVERT_LONG(u);
+
+    if (us < v.sgn)
+        return true;
+
+    if (us > v.sgn)
+        return false;
+
+    // us == v.sgn
+
+    if (us == SC_POS) {
+        if (vec_skip_and_cmp(DIGITS_PER_LONG, ud, v.ndigits, v.digit) < 0)
+            return true;
+    }
+
+    return false;
+}
+
+
+// ---------------------------------------------------------------------------
+//    SECTION: LESS THAN or EQUAL operator: <=
+// ---------------------------------------------------------------------------
+
+// Operators in this section are included from sc_nbcommon.cpp.
+
+
+// ---------------------------------------------------------------------------
+//    SECTION: GREATER THAN operator: >
+// ---------------------------------------------------------------------------
+
+// Operators in this section are included from sc_nbcommon.cpp.
+
+
+// ---------------------------------------------------------------------------
+//    SECTION: GREATER THAN or EQUAL operator: >=
+// ---------------------------------------------------------------------------
+
+// Operators in this section are included from sc_nbcommon.cpp.
+
+
+// ---------------------------------------------------------------------------
+//    SECTION: Public members - Other utils.
+// ---------------------------------------------------------------------------
+
+bool
+sc_signed::iszero() const
+{
+    if (sgn == SC_ZERO)
+        return true;
+    else if (sgn != SC_NOSIGN)
+        return false;
+    else
+        return check_for_zero(ndigits, digit);
+}
+
+
+bool
+sc_signed::sign() const
+{
+    if (sgn == SC_NEG)
+        return 1;
+    else if (sgn != SC_NOSIGN)
+        return 0;
+    else
+        return ((digit[ndigits - 1] & one_and_zeros(bit_ord(nbits - 1))) != 0);
+}
+
+// The rest of the utils in this section are included from sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//    SECTION: Private members.
+// ----------------------------------------------------------------------------
+
+// The private members in this section are included from sc_nbcommon.cpp.
+
+#define CLASS_TYPE sc_signed
+#define CLASS_TYPE_STR "sc_signed"
+
+#define ADD_HELPER add_signed_friend
+#define SUB_HELPER sub_signed_friend
+#define MUL_HELPER mul_signed_friend
+#define DIV_HELPER div_signed_friend
+#define MOD_HELPER mod_signed_friend
+#define AND_HELPER and_signed_friend
+#define OR_HELPER or_signed_friend
+#define XOR_HELPER xor_signed_friend
+
+#include "sc_nbfriends.inc"
+
+#undef SC_UNSIGNED
+#define SC_SIGNED
+#define IF_SC_SIGNED 1 // 1 = sc_signed
+#define CLASS_TYPE_SUBREF sc_signed_subref_r
+#define OTHER_CLASS_TYPE sc_unsigned
+#define OTHER_CLASS_TYPE_SUBREF sc_unsigned_subref_r
+
+#define MUL_ON_HELPER mul_on_help_signed
+#define DIV_ON_HELPER div_on_help_signed
+#define MOD_ON_HELPER mod_on_help_signed
+
+#include "sc_nbcommon.inc"
+
+#undef MOD_ON_HELPER
+#undef DIV_ON_HELPER
+#undef MUL_ON_HELPER
+
+#undef OTHER_CLASS_TYPE_SUBREF
+#undef OTHER_CLASS_TYPE
+#undef CLASS_TYPE_SUBREF
+#undef IF_SC_SIGNED
+#undef SC_SIGNED
+
+#undef XOR_HELPER
+#undef OR_HELPER
+#undef AND_HELPER
+#undef MOD_HELPER
+#undef DIV_HELPER
+#undef MUL_HELPER
+#undef SUB_HELPER
+#undef ADD_HELPER
+
+#undef CLASS_TYPE
+#undef CLASS_TYPE_STR
+
+#include "sc_signed_bitref.inc"
+#include "sc_signed_subref.inc"
+
+#undef CONVERT_LONG
+#undef CONVERT_LONG_2
+#undef CONVERT_INT64
+#undef CONVERT_INT64_2
+
+} // namespace sc_dt
diff --git a/src/systemc/dt/int/sc_signed_bitref.inc b/src/systemc/dt/int/sc_signed_bitref.inc
new file mode 100644
index 0000000..c20301c
--- /dev/null
+++ b/src/systemc/dt/int/sc_signed_bitref.inc
@@ -0,0 +1,163 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_signed_bitref.h -- Proxy class that is declared in sc_signed.h.
+
+  Original Author: Ali Dasdan, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_signed_bitref_r
+//
+//  Proxy class for sc_signed bit selection (r-value only).
+// ----------------------------------------------------------------------------
+
+// implicit conversion to uint64
+
+sc_signed_bitref_r::operator uint64 () const
+{
+    return m_obj_p->test(m_index);
+}
+
+bool
+sc_signed_bitref_r::operator ! () const
+{
+    return (!m_obj_p->test(m_index));
+}
+
+bool
+sc_signed_bitref_r::operator ~ () const
+{
+    return (!m_obj_p->test(m_index));
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_signed_bitref
+//
+//  Proxy class for sc_signed bit selection (r-value and l-value).
+// ----------------------------------------------------------------------------
+
+// assignment operators
+
+const sc_signed_bitref &
+sc_signed_bitref::operator = (const sc_signed_bitref_r &b)
+{
+    m_obj_p->set(m_index, (bool)b);
+    return *this;
+}
+
+const sc_signed_bitref &
+sc_signed_bitref::operator = (const sc_signed_bitref &b)
+{
+    m_obj_p->set(m_index, (bool)b);
+    return *this;
+}
+
+const sc_signed_bitref &
+sc_signed_bitref::operator = (bool b)
+{
+    m_obj_p->set(m_index, b);
+    return *this;
+}
+
+
+const sc_signed_bitref &
+sc_signed_bitref::operator &= (bool b)
+{
+    if (!b) {
+        m_obj_p->clear(m_index);
+    }
+    return *this;
+}
+
+const sc_signed_bitref &
+sc_signed_bitref::operator |= (bool b)
+{
+    if (b) {
+        m_obj_p->set(m_index);
+    }
+    return *this;
+}
+
+const sc_signed_bitref &
+sc_signed_bitref::operator ^= (bool b)
+{
+    if (b) {
+        m_obj_p->invert(m_index);
+    }
+    return *this;
+}
+
+// #### OPTIMIZE
+void
+sc_signed_bitref::concat_set(int64 src, int low_i)  
+{    
+    bool value = 1 & ((low_i < 64) ? (src >> low_i) : (src >> 63));
+    m_obj_p->set(low_i, value);
+}
+
+void
+sc_signed_bitref::concat_set(const sc_signed &src, int low_i)
+{
+    if (low_i < src.length())
+        m_obj_p->set(low_i, src.test(low_i));
+    else
+        m_obj_p->set(low_i, src < 0);
+}       
+
+void
+sc_signed_bitref::concat_set(const sc_unsigned &src, int low_i)
+{
+    if (low_i < src.length())
+        m_obj_p->set(low_i, src.test(low_i));
+    else
+        m_obj_p->set(low_i, 0);
+}
+
+void
+sc_signed_bitref::concat_set(uint64 src, int low_i)
+{
+    bool value = 1 & ((low_i < 64) ? (src >> low_i) : 0);
+    m_obj_p->set(low_i, value);
+}
+
+
+// other methods
+void
+sc_signed_bitref::scan(::std::istream &is)
+{
+    bool b;
+    is >> b;
+    *this = b;
+}
diff --git a/src/systemc/dt/int/sc_signed_subref.inc b/src/systemc/dt/int/sc_signed_subref.inc
new file mode 100644
index 0000000..476c815
--- /dev/null
+++ b/src/systemc/dt/int/sc_signed_subref.inc
@@ -0,0 +1,402 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_signed_subref.h -- Proxy class that is declared in sc_signed.h.
+
+  Original Author: Ali Dasdan, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_signed_subref_r
+//
+//  Proxy class for sc_signed part selection (r-value only).
+// ----------------------------------------------------------------------------
+
+// concatenation support
+
+uint64
+sc_signed_subref_r::concat_get_uint64() const
+{
+    sc_unsigned a(m_obj_p, m_left, m_right);
+    return a.to_uint64();
+}
+
+
+bool
+sc_signed_subref_r::concat_get_ctrl(sc_digit *dst_p, int low_i) const
+{
+    sc_unsigned a(m_obj_p, m_left, m_right);
+    return a.concat_get_ctrl(dst_p, low_i);
+}
+
+
+bool
+sc_signed_subref_r::concat_get_data(sc_digit *dst_p, int low_i) const
+{
+    sc_unsigned a(m_obj_p, m_left, m_right);
+    return a.concat_get_data(dst_p, low_i);
+}
+
+
+// implicit conversion to sc_signed
+sc_signed_subref_r::operator sc_unsigned () const
+{
+    return sc_unsigned(m_obj_p, m_left, m_right);
+}
+
+
+// explicit conversions
+int
+sc_signed_subref_r::to_int() const
+{
+    sc_unsigned a(m_obj_p, m_left, m_right);
+    return a.to_int();
+}
+
+unsigned int
+sc_signed_subref_r::to_uint() const
+{
+    sc_unsigned a(m_obj_p, m_left, m_right);
+    return a.to_uint();
+}
+
+long
+sc_signed_subref_r::to_long() const
+{
+    sc_unsigned a(m_obj_p, m_left, m_right);
+    return a.to_long();
+}
+
+unsigned long
+sc_signed_subref_r::to_ulong() const
+{
+    sc_unsigned a(m_obj_p, m_left, m_right);
+    return a.to_ulong();
+}
+
+int64
+sc_signed_subref_r::to_int64() const
+{
+    sc_unsigned a(m_obj_p, m_left, m_right);
+    return a.to_int64();
+}
+
+uint64
+sc_signed_subref_r::to_uint64() const
+{
+    sc_unsigned a(m_obj_p, m_left, m_right);
+    return a.to_uint64();
+}
+
+double
+sc_signed_subref_r::to_double() const
+{
+    sc_unsigned a(m_obj_p, m_left, m_right);
+    return a.to_double();
+}
+
+
+// explicit conversion to character string
+const std::string
+sc_signed_subref_r::to_string(sc_numrep numrep) const
+{
+    sc_unsigned a(length());
+    a = *this;
+    return a.to_string(numrep);
+}
+
+const std::string
+sc_signed_subref_r::to_string(sc_numrep numrep, bool w_prefix) const
+{
+    sc_unsigned a(length());
+    a = *this;
+    return a.to_string(numrep, w_prefix);
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_signed_subref
+//
+//  Proxy class for sc_signed part selection (r-value and l-value).
+// ----------------------------------------------------------------------------
+
+// assignment operators
+
+const sc_signed_subref &
+sc_signed_subref::operator = (const sc_signed_subref_r &a)
+{
+    return operator = ((sc_unsigned)(a));
+}
+
+const sc_signed_subref &
+sc_signed_subref::operator = (const sc_signed_subref &v)
+{
+    if (this == &v) {
+        return *this;
+    }
+    return operator = ((sc_unsigned)(v));
+}
+
+const sc_signed_subref &
+sc_signed_subref::operator = (const sc_signed &v)
+{
+    int i;
+    int l = sc_min(m_left, v.nbits - 1 + m_right);
+
+    for (i = m_right; i <= l; ++i)
+        m_obj_p->set(i, v.test(i - m_right));
+    for (; i <= m_left; i++)
+        m_obj_p->set(i, v.test(l));
+
+    return *this;
+}
+
+const sc_signed_subref &
+sc_signed_subref::operator = (const sc_unsigned_subref_r &v)
+{
+    return operator = ((sc_unsigned)(v));
+}
+
+const sc_signed_subref &
+sc_signed_subref::operator = (const sc_unsigned &v)
+{
+    int i;
+    int l = sc_min(m_left, v.nbits - 1 + m_right);
+
+    for (i = m_right; i <= l; ++i)
+        m_obj_p->set(i, v.test(i - m_right));
+    for (; i <= m_left; i++)
+        m_obj_p->set(i, 0);
+    return *this;
+}
+
+const sc_signed_subref &
+sc_signed_subref::operator = (unsigned long v)
+{
+    for (int i = m_right; i <= m_left; ++i) {
+        m_obj_p->set(i, static_cast<bool>(v & 1));
+        v >>= 1;
+    }
+    return *this;
+}
+
+const sc_signed_subref &
+sc_signed_subref::operator = (long v)
+{
+    unsigned long v2 = (unsigned long)v;
+    for (int i = m_right; i <= m_left; ++i) {
+        m_obj_p->set(i, static_cast<bool>(v2 & 1));
+        v2 >>= 1;
+    }
+    return *this;
+}
+
+const sc_signed_subref &
+sc_signed_subref::operator = (uint64 v)
+{
+    for (int i = m_right; i <= m_left; ++i) {
+        m_obj_p->set(i, static_cast<bool>(v & 1));
+        v >>= 1;
+    }
+    return *this;
+}
+
+const sc_signed_subref &
+sc_signed_subref::operator = (int64 v)
+{
+    uint64 v2 = (uint64)v;
+    for (int i = m_right; i <= m_left; ++i) {
+        m_obj_p->set(i, static_cast<bool>(v2 & 1));
+        v2 >>= 1;
+    }
+    return *this;
+}
+
+const sc_signed_subref &
+sc_signed_subref::operator = (double v)
+{
+    is_bad_double(v);
+
+    int nb = m_left - m_right + 1;
+    int nd = DIV_CEIL(nb);
+
+#ifdef SC_MAX_NBITS
+    sc_digit d[MAX_NDIGITS];
+#else
+    sc_digit *d = new sc_digit[nd];
+#endif
+
+    if (v < 0)
+        v = -v;
+
+    int i = 0;
+
+    while (std::floor(v) && (i < nd)) {
+#ifndef _WIN32
+        d[i++] = (sc_digit) std::floor(remainder(v, DIGIT_RADIX));
+#else
+        d[i++] = (sc_digit) std::floor(std::fmod(v, DIGIT_RADIX));
+#endif
+        v /= DIGIT_RADIX;
+    }
+
+    vec_zero(i, nd, d);
+    sc_digit val = 1;  // Bit value.
+    int j = 0;   // Current digit in d.
+    i = 0;  // Current bit in d.
+    while (i < nb) {
+        m_obj_p->set(i + m_right, (bool)(d[j] & val));
+        ++i;
+        if (i % BITS_PER_DIGIT == 0) {
+            val = 1;
+            ++j;
+        } else {
+            val <<= 1;
+        }
+    }
+
+#ifndef SC_MAX_NBITS
+    delete [] d;
+#endif
+    return *this;
+}
+
+const sc_signed_subref &
+sc_signed_subref::operator = (const sc_int_base &a)
+{
+    return operator = ((int64)a);
+}
+
+const sc_signed_subref &
+sc_signed_subref::operator = (const sc_uint_base &a)
+{
+    return operator = ((uint64)a);
+}
+
+// concatenation methods
+
+
+void
+sc_signed_subref::concat_set(int64 src, int low_i)
+{
+    int  i;
+    int  l;
+    bool sign = src < 0;
+
+    if (low_i < 64) {
+        src = src >> low_i;
+        l = sc_min(m_left, (63 - low_i) + m_right);
+        for (i = m_right; i <= l; ++i) {
+            m_obj_p->set(i, src & 1);
+            src = src >> 1;
+        }
+        for (; i <= m_left; i++)
+            m_obj_p->set(i, sign);
+    } else {
+        for (i = m_right; i <= m_left; ++i)
+            m_obj_p->set(i, sign);
+    }
+}
+
+void
+sc_signed_subref::concat_set(const sc_signed &src, int low_i)
+{
+    int i;
+    int l;
+    int src_i;
+    bool sign = src.test(src.nbits - 1);
+    l = src.nbits - (low_i + 1);
+    if (l >= 0) {
+        l = sc_min(m_left, l + m_right);
+        src_i = low_i;
+        for (i = m_right; i <= l; ++i, src_i++) {
+            m_obj_p->set(i, src.test(src_i));
+        }
+        for (; i <= m_left; i++)
+            m_obj_p->set(i, sign);
+    } else {
+        for (i = m_right; i <= m_left; ++i)
+            m_obj_p->set(i, sign);
+    }
+}
+
+void
+sc_signed_subref::concat_set(const sc_unsigned &src, int low_i)
+{
+    int i;
+    int l;
+    int src_i;
+    l = src.nbits - (low_i + 2);
+    if (l >= 0) {
+        l = sc_min(m_left, l + m_right);
+        src_i = low_i;
+        for (i = m_right; i <= l; ++i, src_i++) {
+            m_obj_p->set(i, src.test(src_i));
+        }
+        for (; i <= m_left; i++)
+            m_obj_p->set(false);
+    } else {
+        for (i = m_right; i <= m_left; ++i)
+            m_obj_p->set(false);
+    }
+}
+
+void
+sc_signed_subref::concat_set(uint64 src, int low_i)
+{
+    int  i;
+    int  l;
+
+    if (low_i < 64) {
+        src = src >> low_i;
+        l = sc_min(m_left, (63 - low_i) + m_right);
+        for (i = m_right; i <= l; ++i) {
+            m_obj_p->set(i, src & 1);
+            src = src >> 1;
+        }
+        for (; i <= m_left; i++)
+            m_obj_p->set(false);
+    } else {
+        for (i = m_right; i <= m_left; ++i)
+            m_obj_p->set(false);
+    }
+}
+
+// other methods
+void
+sc_signed_subref::scan(::std::istream &is)
+{
+    std::string s;
+    is >> s;
+    *this = s.c_str();
+}
diff --git a/src/systemc/dt/int/sc_uint_base.cc b/src/systemc/dt/int/sc_uint_base.cc
new file mode 100644
index 0000000..58e4605
--- /dev/null
+++ b/src/systemc/dt/int/sc_uint_base.cc
@@ -0,0 +1,708 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_uint_base.cpp -- contains interface definitions between sc_uint and
+                 sc_signed, sc_unsigned, and definitions for sc_uint_subref.
+
+  Original Author: Ali Dasdan, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: sc_uint_base.cpp,v $
+// Revision 1.5  2011/02/18 20:19:15  acg
+//  Andy Goodrich: updating Copyright notice.
+//
+// Revision 1.4  2010/02/04 22:23:29  acg
+//  Andy Goodrich: fixed bug in concatenation reads for part selections,
+//  the mask being used was 32 bits and should have been 64 bits.
+//
+// Revision 1.3  2008/06/19 17:47:57  acg
+//  Andy Goodrich: fixes for bugs. See 2.2.1 RELEASENOTES.
+//
+// Revision 1.2  2007/11/04 21:27:00  acg
+//  Andy Goodrich: changes to make sure the proper value is returned from
+//  concat_get_data().
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:49:32  acg
+// Added $Log command so that CVS check in comments are reproduced in the
+// source.
+//
+
+#include <sstream>
+
+#include "systemc/ext/dt/bit/sc_bv_base.hh"
+#include "systemc/ext/dt/bit/sc_lv_base.hh"
+#include "systemc/ext/dt/fx/sc_ufix.hh"
+#include "systemc/ext/dt/fx/scfx_other_defs.hh"
+#include "systemc/ext/dt/int/sc_signed.hh"
+#include "systemc/ext/dt/int/sc_uint_base.hh"
+#include "systemc/ext/dt/int/sc_unsigned.hh"
+#include "systemc/ext/dt/misc/sc_concatref.hh"
+
+// explicit template instantiations
+namespace sc_core
+{
+
+template class sc_vpool<sc_dt::sc_uint_bitref>;
+template class sc_vpool<sc_dt::sc_uint_subref>;
+
+} // namespace sc_core
+
+namespace sc_dt
+{
+
+// to avoid code bloat in sc_uint_concat<T1,T2>
+
+void
+sc_uint_concref_invalid_length(int length)
+{
+    std::stringstream msg;
+    msg << "sc_uint_concref<T1,T2> initialization: length = " << length <<
+           "violates 1 <= length <= " << SC_INTWIDTH;
+    SC_REPORT_ERROR("out of bounds", msg.str().c_str());
+    sc_core::sc_abort(); // can't recover from here
+}
+
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_uint_bitref
+//
+//  Proxy class for sc_uint bit selection (r-value and l-value).
+// ----------------------------------------------------------------------------
+
+sc_core::sc_vpool<sc_uint_bitref> sc_uint_bitref::m_pool(9);
+
+// concatenation methods:
+
+// #### OPTIMIZE
+void
+sc_uint_bitref::concat_set(int64 src, int low_i)
+{
+    sc_uint_base aa(1);
+    *this = aa = (low_i < 64) ? src >> low_i : src >> 63;
+}
+
+void
+sc_uint_bitref::concat_set(const sc_signed &src, int low_i)
+{
+    sc_uint_base aa(1);
+    if (low_i < src.length())
+        *this = aa = 1 & (src >> low_i);
+    else
+        *this = aa = (src < 0) ? (int_type)-1 : 0;
+}
+
+void
+sc_uint_bitref::concat_set(const sc_unsigned &src, int low_i)
+{
+    sc_uint_base aa(1);
+    if (low_i < src.length())
+        *this = aa = 1 & (src >> low_i);
+    else
+        *this = aa = 0;
+}
+
+void
+sc_uint_bitref::concat_set(uint64 src, int low_i)
+{
+    sc_uint_base aa(1);
+    *this = aa = (low_i < 64) ? src >> low_i : 0;
+}
+
+
+// other methods
+void
+sc_uint_bitref::scan(::std::istream &is)
+{
+    bool b;
+    is >> b;
+    *this = b;
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_uint_subref_r
+//
+//  Proxy class for sc_uint part selection (l-value).
+// ----------------------------------------------------------------------------
+
+bool
+sc_uint_subref_r::concat_get_ctrl(sc_digit *dst_p, int low_i) const
+{
+    int dst_i; // Word in dst_p now processing.
+    int end_i; // Highest order word in dst_p to process.
+    int left_shift; // Left shift for val.
+    uint_type mask; // Mask for bits to extract or keep.
+
+    dst_i = low_i / BITS_PER_DIGIT;
+    left_shift = low_i % BITS_PER_DIGIT;
+    end_i = (low_i + (m_left-m_right)) / BITS_PER_DIGIT;
+
+    mask = ~(~UINT_ZERO << left_shift);
+    dst_p[dst_i] = (sc_digit)((dst_p[dst_i] & mask));
+
+    dst_i++;
+    for (; dst_i <= end_i; dst_i++)
+        dst_p[dst_i] = 0;
+
+    return false;
+}
+
+bool
+sc_uint_subref_r::concat_get_data(sc_digit *dst_p, int low_i) const
+{
+    int dst_i; // Word in dst_p now processing.
+    int end_i; // Highest order word in dst_p to process.
+    int high_i; // Index of high order bit in dst_p to set.
+    int left_shift; // Left shift for val.
+    uint_type mask; // Mask for bits to extract or keep.
+    bool result; // True if inserting non-zero value.
+    uint_type val; // Selection value extracted from m_obj_p.
+
+    dst_i = low_i / BITS_PER_DIGIT;
+    left_shift = low_i % BITS_PER_DIGIT;
+    high_i = low_i + (m_left-m_right);
+    end_i = high_i / BITS_PER_DIGIT;
+    mask = ~mask_int[m_left][m_right];
+    val = (m_obj_p->m_val & mask) >> m_right;
+    result = val != 0;
+
+    // PROCESS THE FIRST WORD:
+    mask = ~(~UINT_ZERO << left_shift);
+    dst_p[dst_i] = (sc_digit)(((dst_p[dst_i] & mask)) |
+        ((val << left_shift) & DIGIT_MASK));
+
+    switch (end_i - dst_i) {
+      // BITS ARE ACROSS TWO WORDS:
+      case 1:
+        dst_i++;
+        val >>= (BITS_PER_DIGIT-left_shift);
+        dst_p[dst_i] = (sc_digit)val;
+        break;
+
+      // BITS ARE ACROSS THREE WORDS:
+      case 2:
+        dst_i++;
+        val >>= (BITS_PER_DIGIT-left_shift);
+        dst_p[dst_i++] = (sc_digit)(val & DIGIT_MASK);
+        val >>= BITS_PER_DIGIT;
+        dst_p[dst_i] = (sc_digit)val;
+        break;
+
+      // BITS ARE ACROSS THREE WORDS:
+      case 3:
+        dst_i++;
+        val >>= (BITS_PER_DIGIT-left_shift);
+        dst_p[dst_i++] = (sc_digit)(val & DIGIT_MASK);
+        val >>= BITS_PER_DIGIT;
+        dst_p[dst_i++] = (sc_digit)(val & DIGIT_MASK);
+        val >>= BITS_PER_DIGIT;
+        dst_p[dst_i] = (sc_digit)val;
+        break;
+    }
+    return result;
+}
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_uint_subref
+//
+//  Proxy class for sc_uint part selection (r-value and l-value).
+// ----------------------------------------------------------------------------
+
+sc_core::sc_vpool<sc_uint_subref> sc_uint_subref::m_pool(9);
+
+// assignment operators
+
+sc_uint_subref &
+sc_uint_subref::operator = (uint_type v)
+{
+    uint_type val = m_obj_p->m_val;
+    uint_type mask = mask_int[m_left][m_right];
+    val &= mask;
+    val |= (v << m_right) & ~mask;
+    m_obj_p->m_val = val;
+    m_obj_p->extend_sign();
+    return *this;
+}
+
+sc_uint_subref &
+sc_uint_subref::operator = (const sc_signed &a)
+{
+    sc_uint_base aa(length());
+    return (*this = aa = a);
+}
+
+sc_uint_subref &
+sc_uint_subref::operator = (const sc_unsigned &a)
+{
+    sc_uint_base aa(length());
+    return (*this = aa = a);
+}
+
+sc_uint_subref &
+sc_uint_subref::operator = (const sc_bv_base &a)
+{
+    sc_uint_base aa(length());
+    return (*this = aa = a);
+}
+
+sc_uint_subref &
+sc_uint_subref::operator = (const sc_lv_base &a)
+{
+    sc_uint_base aa(length());
+    return (*this = aa = a);
+}
+
+// concatenation methods:
+
+// #### OPTIMIZE
+void
+sc_uint_subref::concat_set(int64 src, int low_i)
+{
+    sc_uint_base aa(length());
+    *this = aa = (low_i < 64) ? src >> low_i : src >> 63;
+}
+
+void
+sc_uint_subref::concat_set(const sc_signed &src, int low_i)
+{
+    sc_uint_base aa(length());
+    if (low_i < src.length())
+        *this = aa = src >> low_i;
+    else
+        *this = aa = (src < 0) ? (int_type)-1 : 0;
+}
+
+void
+sc_uint_subref::concat_set(const sc_unsigned &src, int low_i)
+{
+    sc_uint_base aa(length());
+    if (low_i < src.length())
+        *this = aa = src >> low_i;
+    else
+        *this = aa = 0;
+}
+
+void
+sc_uint_subref::concat_set(uint64 src, int low_i)
+{
+    sc_uint_base aa(length());
+    *this = aa = (low_i < 64) ? src >> low_i : 0;
+}
+
+// other methods
+void
+sc_uint_subref::scan(::std::istream &is)
+{
+    std::string s;
+    is >> s;
+    *this = s.c_str();
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_uint_base
+//
+//  Base class for sc_uint.
+// ----------------------------------------------------------------------------
+
+// support methods
+
+void
+sc_uint_base::invalid_length() const
+{
+    std::stringstream msg;
+    msg << "sc_uint[_base] initialization: length = " << m_len <<
+           " violates 1 <= length <= " << SC_INTWIDTH;
+    SC_REPORT_ERROR("out of bounds", msg.str().c_str());
+    sc_core::sc_abort(); // can't recover from here}
+}
+
+void
+sc_uint_base::invalid_index(int i) const
+{
+    std::stringstream msg;
+    msg << "sc_uint[_base] bit selection: index = " << i <<
+           " violates 0 <= index <= " << (m_len - 1);
+    SC_REPORT_ERROR("out of bounds", msg.str().c_str());
+    sc_core::sc_abort(); // can't recover from here
+}
+
+void
+sc_uint_base::invalid_range(int l, int r) const
+{
+    std::stringstream msg;
+    msg << "sc_uint[_base] part selection: " <<
+           "left = " << l << ", right = " << r << " violates " <<
+           (m_len - 1) << " >= left >= right >= 0";
+    SC_REPORT_ERROR("out of bounds", msg.str().c_str());
+    sc_core::sc_abort(); // can't recover from here
+}
+
+
+void
+sc_uint_base::check_value() const
+{
+    uint_type limit = (~UINT_ZERO >> m_ulen);
+    if (m_val > limit) {
+        std::stringstream msg;
+        msg << "sc_uint[_base]: value does not fit into a length of " << m_len;
+        SC_REPORT_WARNING("out of bounds", msg.str().c_str());
+    }
+}
+
+
+// constructors
+sc_uint_base::sc_uint_base(const sc_bv_base &v) :
+    m_val(0), m_len(v.length()), m_ulen(SC_INTWIDTH - m_len)
+{
+    check_length();
+    *this = v;
+}
+sc_uint_base::sc_uint_base(const sc_lv_base &v) :
+    m_val(0), m_len(v.length()), m_ulen(SC_INTWIDTH - m_len)
+{
+    check_length();
+    *this = v;
+}
+sc_uint_base::sc_uint_base(const sc_int_subref_r &v) :
+    m_val(0), m_len(v.length()), m_ulen(SC_INTWIDTH - m_len)
+{
+    check_length();
+    *this = v.to_uint64();
+}
+sc_uint_base::sc_uint_base(const sc_signed_subref_r &v) :
+    m_val(0), m_len(v.length()), m_ulen(SC_INTWIDTH - m_len)
+{
+    check_length();
+    *this = v.to_uint64();
+}
+sc_uint_base::sc_uint_base(const sc_unsigned_subref_r &v) :
+    m_val(0), m_len(v.length()), m_ulen(SC_INTWIDTH - m_len)
+{
+    check_length();
+    *this = v.to_uint64();
+}
+
+sc_uint_base::sc_uint_base(const sc_signed &a) :
+    m_val(0), m_len(a.length()), m_ulen(SC_INTWIDTH - m_len)
+{
+    check_length();
+    *this = a.to_uint64();
+}
+
+sc_uint_base::sc_uint_base(const sc_unsigned &a) :
+    m_val(0), m_len(a.length()), m_ulen(SC_INTWIDTH - m_len)
+{
+    check_length();
+    *this = a.to_uint64();
+}
+
+// assignment operators
+
+sc_uint_base &
+sc_uint_base::operator = (const sc_signed &a)
+{
+    int minlen = sc_min(m_len, a.length());
+    int i = 0;
+    for (; i < minlen; ++i) {
+        set(i, a.test(i));
+    }
+    bool sgn = a.sign();
+    for (; i < m_len; ++i) {
+        // sign extension
+        set(i, sgn);
+    }
+    extend_sign();
+    return *this;
+}
+
+sc_uint_base &
+sc_uint_base::operator = (const sc_unsigned &a)
+{
+    int minlen = sc_min(m_len, a.length());
+    int i = 0;
+    for (; i < minlen; ++i) {
+        set(i, a.test(i));
+    }
+    for (; i < m_len; ++i) {
+        // zero extension
+        set(i, 0);
+    }
+    extend_sign();
+    return *this;
+}
+
+
+sc_uint_base &
+sc_uint_base::operator = (const sc_bv_base &a)
+{
+    int minlen = sc_min(m_len, a.length());
+    int i = 0;
+    for (; i < minlen; ++i) {
+        set(i, a.get_bit(i));
+    }
+    for (; i < m_len; ++i) {
+        // zero extension
+        set(i, 0);
+    }
+    extend_sign();
+    return *this;
+}
+
+sc_uint_base &
+sc_uint_base::operator = (const sc_lv_base &a)
+{
+    int minlen = sc_min(m_len, a.length());
+    int i = 0;
+    for (; i < minlen; ++i) {
+        set(i, sc_logic(a.get_bit(i)).to_bool());
+    }
+    for (; i < m_len; ++i) {
+        // zero extension
+        set(i, 0);
+    }
+    extend_sign();
+    return *this;
+}
+
+sc_uint_base &
+sc_uint_base::operator = (const char *a)
+{
+    if (a == 0) {
+        SC_REPORT_ERROR("conversion failed",
+                        "character string is zero");
+    } else if (*a == 0) {
+        SC_REPORT_ERROR("conversion failed",
+                        "character string is empty");
+    } else try {
+        int len = m_len;
+        sc_ufix aa(a, len, len, SC_TRN, SC_WRAP, 0, SC_ON);
+        return this->operator = (aa);
+    } catch(const sc_core::sc_report &) {
+        std::stringstream msg;
+        msg << "character string '" << a << "' is not valid";
+        SC_REPORT_ERROR("conversion failed", msg.str().c_str());
+    }
+    return *this;
+}
+
+
+// explicit conversion to character string
+const std::string
+sc_uint_base::to_string(sc_numrep numrep) const
+{
+    int len = m_len;
+    sc_ufix aa(*this, len, len, SC_TRN, SC_WRAP, 0, SC_ON);
+    return aa.to_string(numrep);
+}
+
+const std::string
+sc_uint_base::to_string(sc_numrep numrep, bool w_prefix) const
+{
+    int len = m_len;
+    sc_ufix aa(*this, len, len, SC_TRN, SC_WRAP, 0, SC_ON);
+    return aa.to_string(numrep, w_prefix);
+}
+
+
+// reduce methods
+bool
+sc_uint_base::and_reduce() const
+{
+    return (m_val == (~UINT_ZERO >> m_ulen));
+}
+
+bool
+sc_uint_base::or_reduce() const
+{
+    return (m_val != uint_type(0));
+}
+
+bool
+sc_uint_base::xor_reduce() const
+{
+    uint_type mask = ~UINT_ZERO;
+    uint_type val = m_val;
+    int n = SC_INTWIDTH;
+    do {
+        n >>= 1;
+        mask >>= n;
+        val = ((val & (mask << n)) >> n) ^ (val & mask);
+    } while (n != 1);
+    return (val != uint_type(0));
+}
+
+
+bool
+sc_uint_base::concat_get_ctrl(sc_digit *dst_p, int low_i) const
+{
+    int dst_i; // Word in dst_p now processing.
+    int end_i; // Highest order word in dst_p to process.
+    int left_shift; // Left shift for val.
+    uint_type mask; // Mask for bits to extract or keep.
+
+    dst_i = low_i / BITS_PER_DIGIT;
+    left_shift = low_i % BITS_PER_DIGIT;
+    end_i = (low_i + (m_len - 1)) / BITS_PER_DIGIT;
+
+    // PROCESS THE FIRST WORD:
+    mask = ~(~UINT_ZERO << left_shift);
+    dst_p[dst_i] = (sc_digit)((dst_p[dst_i] & mask));
+
+    dst_i++;
+    for (; dst_i <= end_i; dst_i++)
+        dst_p[dst_i] = 0;
+    return false;
+}
+
+//-----------------------------------------------------------------------------
+//"sc_uint_base::concat_get_data"
+//
+// This method transfers the value of this object instance to the supplied
+// array of sc_unsigned digits starting with the bit specified by low_i within
+// the array of digits.
+//
+// Notes:
+//   (1) we don't worry about masking the high order data we transfer since
+//       concat_get_data() is called from low order bit to high order bit. So
+//       the bits above where we place ours will be filled in by someone else.
+//
+//   dst_p -> array of sc_unsigned digits to be filled in.
+//   low_i =  first bit within dst_p to be set.
+//-----------------------------------------------------------------------------
+bool
+sc_uint_base::concat_get_data(sc_digit *dst_p, int low_i) const
+{
+    int dst_i; // Word in dst_p now processing.
+    int end_i; // Highest order word in dst_p to process.
+    int high_i; // Index of high order bit in dst_p to set.
+    int left_shift; // Left shift for val.
+    uint_type mask; // Mask for bits to extract or keep.
+    bool result; // True if inserting non-zero value.
+    uint_type val; // Value for this object.
+
+    dst_i = low_i / BITS_PER_DIGIT;
+    left_shift = low_i % BITS_PER_DIGIT;
+    high_i = low_i + (m_len - 1);
+    end_i = high_i / BITS_PER_DIGIT;
+    val = m_val;
+    result = val != 0;
+
+    // MASK OFF DATA TO BE TRANSFERRED BASE ON WIDTH:
+    if (m_len < 64) {
+        mask = ~(~UINT_ZERO << m_len);
+        val &=  mask;
+    }
+
+    // PROCESS THE FIRST WORD:
+    mask = ~(~UINT_ZERO << left_shift);
+    dst_p[dst_i] = (sc_digit)(((dst_p[dst_i] & mask)) |
+        ((val << left_shift) & DIGIT_MASK));
+
+    switch (end_i - dst_i) {
+      // BITS ARE ACROSS TWO WORDS:
+      case 1:
+        dst_i++;
+        val >>= (BITS_PER_DIGIT - left_shift);
+        dst_p[dst_i] = (sc_digit)val;
+        break;
+
+      // BITS ARE ACROSS THREE WORDS:
+      case 2:
+        dst_i++;
+        val >>= (BITS_PER_DIGIT - left_shift);
+        dst_p[dst_i++] = (sc_digit)(val & DIGIT_MASK);
+        val >>= BITS_PER_DIGIT;
+        dst_p[dst_i] = (sc_digit)val;
+        break;
+
+      // BITS ARE ACROSS FOUR WORDS:
+      case 3:
+        dst_i++;
+        val >>= (BITS_PER_DIGIT - left_shift);
+        dst_p[dst_i++] = (sc_digit)(val & DIGIT_MASK);
+        val >>= BITS_PER_DIGIT;
+        dst_p[dst_i++] = (sc_digit)(val & DIGIT_MASK);
+        val >>= BITS_PER_DIGIT;
+        dst_p[dst_i] = (sc_digit)val;
+        break;
+    }
+    return result;
+}
+
+// #### OPTIMIZE
+void
+sc_uint_base::concat_set(int64 src, int low_i)
+{
+    *this = (low_i < 64) ? src >> low_i : src >> 63;
+}
+
+void
+sc_uint_base::concat_set(const sc_signed &src, int low_i)
+{
+    if (low_i < src.length())
+        *this = src >> low_i;
+    else
+        *this = (src < 0) ? (int_type)-1 : 0;
+}
+
+void
+sc_uint_base::concat_set(const sc_unsigned &src, int low_i)
+{
+    if (low_i < src.length())
+        *this = src >> low_i;
+    else
+        *this = 0;
+}
+
+void
+sc_uint_base::concat_set(uint64 src, int low_i)
+{
+    *this = (low_i < 64) ? src >> low_i : 0;
+}
+
+
+// other methods
+void
+sc_uint_base::scan(::std::istream &is)
+{
+    std::string s;
+    is >> s;
+    *this = s.c_str();
+}
+
+} // namespace sc_dt
diff --git a/src/systemc/dt/int/sc_unsigned.cc b/src/systemc/dt/int/sc_unsigned.cc
new file mode 100644
index 0000000..d2535b6
--- /dev/null
+++ b/src/systemc/dt/int/sc_unsigned.cc
@@ -0,0 +1,2259 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_unsigned.cpp -- Arbitrary precision signed arithmetic.
+
+    This file includes the definitions of sc_unsigned_bitref,
+    sc_unsigned_subref, and sc_unsigned classes. The first two classes
+    are proxy classes to reference one bit and a range of bits of a
+    sc_unsigned number, respectively. This file also includes
+    sc_nbcommon.cpp and sc_nbfriends.cpp, which contain the
+    definitions shared by sc_unsigned.
+
+  Original Author: Ali Dasdan, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: sc_unsigned.cpp,v $
+// Revision 1.7  2011/02/18 20:19:15  acg
+//  Andy Goodrich: updating Copyright notice.
+//
+// Revision 1.6  2008/12/10 20:38:45  acg
+//  Andy Goodrich: fixed conversion of double values to the digits vector.
+//  The bits above the radix were not being masked off.
+//
+// Revision 1.5  2008/06/19 17:47:57  acg
+//  Andy Goodrich: fixes for bugs. See 2.2.1 RELEASENOTES.
+//
+// Revision 1.4  2008/06/19 16:57:57  acg
+//  Andy Goodrich: added case for negative unsigned values to the support in
+//  concate_get_data().
+//
+// Revision 1.3  2007/11/04 21:27:00  acg
+//  Andy Goodrich: changes to make sure the proper value is returned from
+//  concat_get_data().
+//
+// Revision 1.2  2007/02/22 21:35:05  acg
+//  Andy Goodrich: cleaned up comments in concat_get_ctrl and concat_get_data.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.4  2006/08/29 23:36:54  acg
+//  Andy Goodrich: fixed and_reduce and optimized or_reduce.
+//
+// Revision 1.3  2006/01/13 18:49:32  acg
+// Added $Log command so that CVS check in comments are reproduced in the
+// source.
+//
+
+#include <cctype>
+#include <cmath>
+#include <sstream>
+
+#include "systemc/ext/dt/bit/sc_bv_base.hh"
+#include "systemc/ext/dt/bit/sc_lv_base.hh"
+#include "systemc/ext/dt/fx/sc_ufix.hh"
+#include "systemc/ext/dt/fx/scfx_other_defs.hh"
+#include "systemc/ext/dt/int/sc_int_base.hh"
+#include "systemc/ext/dt/int/sc_signed.hh"
+#include "systemc/ext/dt/int/sc_uint_base.hh"
+#include "systemc/ext/dt/int/sc_unsigned.hh"
+#include "systemc/ext/dt/misc/sc_concatref.hh"
+
+// explicit template instantiations
+namespace sc_core
+{
+
+template class sc_vpool<sc_dt::sc_unsigned_bitref>;
+template class sc_vpool<sc_dt::sc_unsigned_subref>;
+template class sc_vpool<sc_dt::sc_unsigned>;
+
+} // namespace sc_core
+
+namespace sc_dt
+{
+
+// Pool of temporary instances:
+//   The sc_unsigned pool is used by the concatenation support.
+//   The bit and part reference pools allow references to be returned.
+
+sc_core::sc_vpool<sc_unsigned> sc_unsigned::m_pool(8);
+sc_core::sc_vpool<sc_unsigned_bitref> sc_unsigned_bitref::m_pool(9);
+sc_core::sc_vpool<sc_unsigned_subref> sc_unsigned_subref::m_pool(9);
+
+
+void
+sc_unsigned::invalid_init(const char *type_name, int nb) const
+{
+    std::stringstream msg;
+    msg << "sc_unsigned("<< type_name << ") : nb = " << nb << " is not valid";
+    SC_REPORT_ERROR("initialization failed", msg.str().c_str());
+}
+
+
+// ----------------------------------------------------------------------------
+// SECTION: Public members - Invalid selections.
+// ----------------------------------------------------------------------------
+
+void
+sc_unsigned::invalid_index(int i) const
+{
+    std::stringstream msg;
+    msg << "sc_biguint bit selection: index = " << i << " violates "
+           "0 <= index <= " << (nbits-2);
+    SC_REPORT_ERROR("out of bounds", msg.str().c_str());
+    sc_core::sc_abort(); // can't recover from here
+}
+
+void
+sc_unsigned::invalid_range(int l, int r) const
+{
+    std::stringstream msg;
+    msg << "sc_biguint part selection: left = " <<
+           l << ", right = " << r << "\n"
+           "  violates either (" << (nbits - 2) << " >= left >= 0) or "
+           "(" << (nbits-2) << " >= right >= 0)";
+    SC_REPORT_ERROR("out of bounds", msg.str().c_str());
+    sc_core::sc_abort(); // can't recover from here
+}
+
+// ----------------------------------------------------------------------------
+//  SECTION: Public members - Concatenation support.
+// ----------------------------------------------------------------------------
+
+// Most public members are included from sc_nbcommon.inc. However, some
+// concatenation support appears here to optimize between the signed and
+// unsigned cases.
+
+
+
+// Insert this object's value at the specified place in a vector of big style
+// values.
+
+bool
+sc_unsigned::concat_get_ctrl(sc_digit *dst_p, int low_i) const
+{
+    int dst_i; // Index to next word to set in dst_p.
+    int end_i; // Index of high order word to set.
+    int left_shift; // Amount to shift value left.
+    sc_digit mask; // Mask for partial word sets.
+
+
+    // CALCULATE METRICS FOR DATA MOVEMENT:
+    dst_i = low_i / BITS_PER_DIGIT;
+    end_i = (low_i + nbits - 2) / BITS_PER_DIGIT;
+    left_shift = low_i % BITS_PER_DIGIT;
+
+    // MOVE FIRST WORD (IT MAY BE PARTIAL) AND THEN ANY OTHERS:
+    //
+    // We may "clobber" upper bits, but they will be written at some point
+    // anyway.
+
+    mask = ~(~0U << left_shift);
+    dst_p[dst_i] = (dst_p[dst_i] & ~mask);
+    dst_i++;
+
+    for (; dst_i <= end_i; dst_i++)
+        dst_p[dst_i] = 0;
+
+    return false;
+}
+
+bool
+sc_unsigned::concat_get_data(sc_digit *dst_p, int low_i) const
+{
+    sc_digit carry; // Carry for negating value.
+    int dst_i; // Index to next word to set in dst_p.
+    int end_i; // Index of high order word to set.
+    int high_i; // Index w/in word of high order bit.
+    int left_shift; // Amount to shift value left.
+    sc_digit left_word; // High word component for set.
+    sc_digit mask; // Mask for partial word sets.
+    bool result; // True if inserting non-zero data.
+    int right_shift; // Amount to shift value right.
+    sc_digit right_word; // Low word component for set.
+    int real_bits; // nbits - 1.
+    int src_i; // Index to next word to get from digit.
+
+    // CALCULATE METRICS FOR DATA MOVEMENT:
+    real_bits = nbits - 1; // Remove that extra sign bit.
+    dst_i = low_i / BITS_PER_DIGIT;
+    high_i = low_i + real_bits - 1;
+    end_i = high_i / BITS_PER_DIGIT;
+    left_shift = low_i % BITS_PER_DIGIT;
+
+    switch (sgn) {
+      // POSITIVE SOURCE VALUE:
+      case SC_POS:
+        result = true;
+
+        // ALL DATA TO BE MOVED IS IN A SINGLE WORD:
+        if (dst_i == end_i) {
+            mask = ~(~0U << left_shift);
+            dst_p[dst_i] = ((dst_p[dst_i] & mask) |
+                (digit[0] << left_shift)) & DIGIT_MASK;
+
+        // DATA IS IN MORE THAN ONE WORD, BUT IS WORD ALIGNED:
+        } else if (left_shift == 0) {
+            for (src_i = 0; dst_i < end_i; dst_i++, src_i++) {
+                dst_p[dst_i] = digit[src_i];
+            }
+            high_i = high_i % BITS_PER_DIGIT;
+            mask = ~(~1U << high_i) & DIGIT_MASK;
+            dst_p[dst_i] = digit[src_i] & mask;
+
+        // DATA IS IN MORE THAN ONE WORD, AND NOT WORD ALIGNED:
+        } else {
+            high_i = high_i % BITS_PER_DIGIT;
+            right_shift = BITS_PER_DIGIT - left_shift;
+            mask = ~(~0U << left_shift);
+            right_word = digit[0];
+            dst_p[dst_i] = (dst_p[dst_i] & mask) |
+                ((right_word << left_shift) & DIGIT_MASK);
+            for (src_i = 1, dst_i++; dst_i < end_i; dst_i++, src_i++) {
+                left_word = digit[src_i];
+                dst_p[dst_i] = ((left_word << left_shift) & DIGIT_MASK) |
+                    (right_word >> right_shift);
+                right_word = left_word;
+            }
+            left_word = (src_i < ndigits) ? digit[src_i] : 0;
+            mask = ~(~1U << high_i) & DIGIT_MASK;
+            dst_p[dst_i] = ((left_word << left_shift) |
+                (right_word >> right_shift)) & mask;
+        }
+        break;
+
+      // SOURCE VALUE IS NEGATIVE:
+      case SC_NEG:
+        // ALL DATA TO BE MOVED IS IN A SINGLE WORD:
+        result = true;
+        if (dst_i == end_i) {
+            mask = ~(~0U << nbits);
+            right_word = ((digit[0] ^ DIGIT_MASK) + 1) & mask;
+            mask = ~(~0U << left_shift);
+            dst_p[dst_i] = ((dst_p[dst_i] & mask) |
+                (right_word << left_shift)) & DIGIT_MASK;
+
+        // DATA IS IN MORE THAN ONE WORD, BUT IS WORD ALIGNED:
+
+        } else if (left_shift == 0) {
+            carry = 1;
+            for (src_i = 0; dst_i < end_i; dst_i++, src_i++) {
+                right_word = (digit[src_i] ^ DIGIT_MASK) + carry;
+                dst_p[dst_i] = right_word &  DIGIT_MASK;
+                carry = right_word >> BITS_PER_DIGIT;
+            }
+            high_i = high_i % BITS_PER_DIGIT;
+            mask = (~(~1U << high_i)) & DIGIT_MASK;
+            right_word = (src_i < ndigits) ?
+                (digit[src_i] ^ DIGIT_MASK) + carry : DIGIT_MASK + carry;
+            dst_p[dst_i] = right_word & mask;
+
+        // DATA IS IN MORE THAN ONE WORD, AND NOT WORD ALIGNED:
+        } else {
+            high_i = high_i % BITS_PER_DIGIT;
+            right_shift = BITS_PER_DIGIT - left_shift;
+            mask = ~(~0U << left_shift);
+            carry = 1;
+            right_word = (digit[0] ^ DIGIT_MASK) + carry;
+            dst_p[dst_i] = (dst_p[dst_i] & mask) |
+                ((right_word << left_shift) & DIGIT_MASK);
+            carry = right_word >> BITS_PER_DIGIT;
+            right_word &= DIGIT_MASK;
+            for (src_i = 1, dst_i++; dst_i < end_i; dst_i++, src_i++) {
+                left_word = (digit[src_i] ^ DIGIT_MASK) + carry;
+                dst_p[dst_i] = ((left_word << left_shift)&DIGIT_MASK) |
+                    (right_word >> right_shift);
+                carry = left_word >> BITS_PER_DIGIT;
+                right_word = left_word & DIGIT_MASK;
+            }
+            left_word = (src_i < ndigits) ?
+                (digit[src_i] ^ DIGIT_MASK) + carry : carry;
+            mask = ~(~1U << high_i) & DIGIT_MASK;
+            dst_p[dst_i] = ((left_word << left_shift) |
+                (right_word >> right_shift)) & mask;
+        }
+        break;
+      // VALUE IS ZERO:
+      default:
+        result = false;
+        // ALL DATA TO BE MOVED IS IN A SINGLE WORD:
+        if (dst_i == end_i) {
+            mask = ~(~0U << real_bits) << left_shift;
+            dst_p[dst_i] = dst_p[dst_i] & ~mask;
+
+        // DATA IS IN MORE THAN ONE WORD, BUT IS WORD ALIGNED:
+
+        } else if (left_shift == 0) {
+            for (src_i = 0; dst_i < end_i; dst_i++, src_i++) {
+                dst_p[dst_i] = 0;
+            }
+            dst_p[dst_i] = 0;
+
+        // DATA IS IN MORE THAN ONE WORD, AND NOT WORD ALIGNED:
+        } else {
+            mask = ~(~0U << left_shift);
+            dst_p[dst_i] = (dst_p[dst_i] & mask);
+            for (dst_i++; dst_i <= end_i; dst_i++) {
+                dst_p[dst_i] = 0;
+            }
+        }
+        break;
+    }
+    return result;
+}
+
+// Return this object instance's bits as a uint64 without sign extension.
+uint64
+sc_unsigned::concat_get_uint64() const
+{
+    uint64 result;
+
+    switch (sgn) {
+      case SC_POS:
+        result = 0;
+        if (ndigits > 2)
+            result = digit[2];
+        if (ndigits > 1)
+            result = (result << BITS_PER_DIGIT) | digit[1];
+        result = (result << BITS_PER_DIGIT) | digit[0];
+        break;
+      default:
+        result = 0;
+        break;
+    }
+    return result;
+}
+
+// #### OPTIMIZE
+void
+sc_unsigned::concat_set(int64 src, int low_i)
+{
+    *this = (low_i < 64) ? src >> low_i : src >> 63;
+}
+
+void
+sc_unsigned::concat_set(const sc_signed &src, int low_i)
+{
+    if (low_i < src.length())
+        *this = src >> low_i;
+    else
+        *this = (src < 0) ? (int_type)-1 : 0;
+}
+
+void
+sc_unsigned::concat_set(const sc_unsigned &src, int low_i)
+{
+    if (low_i < src.length())
+        *this = src >> low_i;
+    else
+        *this = 0;
+}
+
+void
+sc_unsigned::concat_set(uint64 src, int low_i)
+{
+    *this = (low_i < 64) ? src >> low_i : 0;
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Public members - Reduction methods.
+// ----------------------------------------------------------------------------
+
+bool
+sc_unsigned::and_reduce() const
+{
+    int i; // Digit examining.
+
+    if (sgn == SC_ZERO)
+        return false;
+    for (i = 0; i < ndigits - 1; i++)
+        if ((digit[i] & DIGIT_MASK) != DIGIT_MASK)
+            return false;
+    if ((digit[i] & ~(~0U << ((nbits - 1) % BITS_PER_DIGIT))) ==
+         static_cast<sc_digit>(~(~0U << ((nbits - 1) % BITS_PER_DIGIT)))) {
+        return true;
+    }
+    return false;
+}
+
+bool
+sc_unsigned::or_reduce() const
+{
+        return (sgn == SC_ZERO) ? false : true;
+}
+
+bool
+sc_unsigned::xor_reduce() const
+{
+    int i; // Digit examining.
+    int odd; // Flag for odd number of digits.
+
+    odd = 0;
+    for (i = 0; i < nbits - 1; i++)
+        if (test(i))
+            odd = ~odd;
+    return odd ? true : false;
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Public members - Assignment operators.
+// ----------------------------------------------------------------------------
+
+// assignment operators
+const sc_unsigned &
+sc_unsigned::operator = (const char *a)
+{
+    if (a == 0) {
+        SC_REPORT_ERROR("conversion failed",
+                        "character string is zero");
+    } else if (*a == 0) {
+        SC_REPORT_ERROR("conversion failed",
+                        "character string is empty");
+    } else try {
+        int len = length();
+        sc_ufix aa(a, len, len, SC_TRN, SC_WRAP, 0, SC_ON);
+        return this->operator = (aa);
+    } catch(const sc_core::sc_report &) {
+        std::stringstream msg;
+        msg << "character string '" << a << "' is not valid";
+        SC_REPORT_ERROR("conversion failed", msg.str().c_str());
+    }
+    return *this;
+}
+
+const sc_unsigned &
+sc_unsigned::operator = (int64 v)
+{
+    sgn = get_sign(v);
+    if (sgn == SC_ZERO) {
+        vec_zero(ndigits, digit);
+    } else {
+        from_uint(ndigits, digit, (uint64) v);
+        convert_SM_to_2C_to_SM();
+    }
+    return *this;
+}
+
+const sc_unsigned &
+sc_unsigned::operator = (uint64 v)
+{
+    if (v == 0) {
+        sgn = SC_ZERO;
+        vec_zero(ndigits, digit);
+    } else {
+        sgn = SC_POS;
+        from_uint(ndigits, digit, v);
+        convert_SM_to_2C_to_SM();
+    }
+    return *this;
+}
+
+const sc_unsigned &
+sc_unsigned::operator = (long v)
+{
+    sgn = get_sign(v);
+    if (sgn == SC_ZERO) {
+        vec_zero(ndigits, digit);
+    } else {
+        from_uint(ndigits, digit, (unsigned long)v);
+        convert_SM_to_2C_to_SM();
+    }
+    return *this;
+}
+
+const sc_unsigned &
+sc_unsigned::operator = (unsigned long v)
+{
+    if (v == 0) {
+        sgn = SC_ZERO;
+        vec_zero(ndigits, digit);
+    } else {
+        sgn = SC_POS;
+        from_uint(ndigits, digit, v);
+        convert_SM_to_2C_to_SM();
+    }
+    return *this;
+}
+
+const sc_unsigned &
+sc_unsigned::operator = (double v)
+{
+    is_bad_double(v);
+    sgn = SC_POS;
+    int i = 0;
+    while (std::floor(v) && (i < ndigits)) {
+        digit[i++] = ((sc_digit)std::floor(remainder(v, DIGIT_RADIX))) &
+            DIGIT_MASK;
+        v /= DIGIT_RADIX;
+    }
+    vec_zero(i, ndigits, digit);
+    convert_SM_to_2C_to_SM();
+    return *this;
+}
+
+
+// ----------------------------------------------------------------------------
+
+const sc_unsigned &
+sc_unsigned::operator = (const sc_bv_base &v)
+{
+    int minlen = sc_min(nbits, v.length());
+    int i = 0;
+    for (; i < minlen; ++i) {
+        safe_set(i, v.get_bit(i), digit);
+    }
+    for (; i < nbits; ++i) {
+        safe_set(i, 0, digit); // zero-extend
+    }
+    convert_2C_to_SM();
+    return *this;
+}
+
+const sc_unsigned &
+sc_unsigned::operator = (const sc_lv_base &v)
+{
+    int minlen = sc_min(nbits, v.length());
+    int i = 0;
+    for (; i < minlen; ++i) {
+        safe_set(i, sc_logic(v.get_bit(i)).to_bool(), digit);
+    }
+    for (; i < nbits; ++i) {
+        safe_set(i, 0, digit);  // zero-extend
+    }
+    convert_2C_to_SM();
+    return *this;
+}
+
+
+// explicit conversion to character string
+const std::string
+sc_unsigned::to_string(sc_numrep numrep) const
+{
+    int len = length();
+    sc_ufix aa(*this, len, len, SC_TRN, SC_WRAP, 0, SC_ON);
+    return aa.to_string(numrep);
+}
+
+const std::string
+sc_unsigned::to_string(sc_numrep numrep, bool w_prefix) const
+{
+    int len = length();
+    sc_ufix aa(*this, len, len, SC_TRN, SC_WRAP, 0, SC_ON);
+    return aa.to_string(numrep, w_prefix);
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Interfacing with sc_int_base
+// ----------------------------------------------------------------------------
+
+const sc_unsigned &
+sc_unsigned::operator = (const sc_int_base &v)
+{
+    return operator = ((int64)v);
+}
+
+const sc_unsigned &
+sc_unsigned::operator += (const sc_int_base &v)
+{
+    return operator += ((int64)v);
+}
+
+const sc_unsigned &
+sc_unsigned::operator -= (const sc_int_base &v)
+{
+    return operator -= ((int64)v);
+}
+
+const sc_unsigned &
+sc_unsigned::operator *= (const sc_int_base &v)
+{
+    return operator *= ((int64)v);
+}
+
+const sc_unsigned &
+sc_unsigned::operator /= (const sc_int_base &v)
+{
+    return operator /= ((int64)v);
+}
+
+const sc_unsigned &
+sc_unsigned::operator %= (const sc_int_base &v)
+{
+    return operator %= ((int64)v);
+}
+
+const sc_unsigned &
+sc_unsigned::operator &= (const sc_int_base &v)
+{
+    return operator &= ((int64)v);
+}
+
+const sc_unsigned &
+sc_unsigned::operator |= (const sc_int_base &v)
+{
+    return operator |= ((int64)v);
+}
+
+const sc_unsigned &
+sc_unsigned::operator ^= (const sc_int_base &v)
+{
+    return operator ^= ((int64)v);
+}
+
+sc_unsigned
+operator << (const sc_unsigned &u, const sc_int_base &v)
+{
+    return operator << (u, (int64)v);
+}
+const sc_unsigned &
+sc_unsigned::operator <<= (const sc_int_base &v)
+{
+    return operator <<= ((int64)v);
+}
+
+sc_unsigned
+operator >> (const sc_unsigned&    u, const sc_int_base&  v)
+{
+    return operator >> (u, (int64)v);
+}
+const sc_unsigned &
+sc_unsigned::operator >>= (const sc_int_base&  v)
+{
+    return operator >>= ((int64)v);
+}
+
+bool
+operator == (const sc_unsigned &u, const sc_int_base &v)
+{
+    return operator == (u, (int64)v);
+}
+bool
+operator == (const sc_int_base &u, const sc_unsigned &v)
+{
+    return operator == ((int64)u, v);
+}
+
+bool
+operator != (const sc_unsigned &u, const sc_int_base &v)
+{
+    return operator != (u, (int64)v);
+}
+bool
+operator != (const sc_int_base &u, const sc_unsigned &v)
+{
+    return operator != ((int64)u, v);
+}
+
+bool
+operator < (const sc_unsigned &u, const sc_int_base &v)
+{
+    return operator < (u, (int64)v);
+}
+bool
+operator < (const sc_int_base &u, const sc_unsigned &v)
+{
+    return operator < ((int64)u, v);
+}
+
+bool
+operator <= (const sc_unsigned &u, const sc_int_base &v)
+{
+    return operator <= (u, (int64)v);
+}
+bool
+operator <= (const sc_int_base &u, const sc_unsigned &v)
+{
+    return operator <= ((int64)u, v);
+}
+
+bool
+operator > (const sc_unsigned &u, const sc_int_base &v)
+{
+    return operator > (u, (int64)v);
+}
+bool
+operator > (const sc_int_base &u, const sc_unsigned &v)
+{
+    return operator > ((int64)u, v);
+}
+
+bool
+operator >= (const sc_unsigned &u, const sc_int_base &v)
+{
+    return operator >= (u, (int64)v);
+}
+bool
+operator >= (const sc_int_base &u, const sc_unsigned &v)
+{
+    return operator >= ((int64)u, v);
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Interfacing with sc_uint_base
+// ----------------------------------------------------------------------------
+
+const sc_unsigned &
+sc_unsigned::operator = (const sc_uint_base &v)
+{
+    return operator = ((uint64)v);
+}
+
+sc_unsigned
+operator + (const sc_unsigned &u, const sc_uint_base &v)
+{
+    return operator + (u, (uint64)v);
+}
+sc_unsigned
+operator + (const sc_uint_base &u, const sc_unsigned &v)
+{
+    return operator + ((uint64)u, v);
+}
+const sc_unsigned &
+sc_unsigned::operator += (const sc_uint_base &v)
+{
+    return operator += ((uint64)v);
+}
+
+const sc_unsigned &
+sc_unsigned::operator -= (const sc_uint_base &v)
+{
+    return operator -= ((uint64)v);
+}
+
+sc_unsigned
+operator * (const sc_unsigned &u, const sc_uint_base &v)
+{
+    return operator * (u, (uint64)v);
+}
+sc_unsigned
+operator * (const sc_uint_base &u, const sc_unsigned &v)
+{
+    return operator * ((uint64)u, v);
+}
+const sc_unsigned &
+sc_unsigned::operator *= (const sc_uint_base &v)
+{
+    return operator *= ((uint64)v);
+}
+
+sc_unsigned
+operator / (const sc_unsigned &u, const sc_uint_base &v)
+{
+    return operator / (u, (uint64)v);
+}
+sc_unsigned
+operator / (const sc_uint_base &u, const sc_unsigned &v)
+{
+    return operator / ((uint64)u, v);
+}
+const sc_unsigned &
+sc_unsigned::operator /= (const sc_uint_base &v)
+{
+    return operator /= ((uint64)v);
+}
+
+sc_unsigned
+operator % (const sc_unsigned &u, const sc_uint_base &v)
+{
+    return operator % (u, (uint64)v);
+}
+sc_unsigned
+operator % (const sc_uint_base &u, const sc_unsigned &v)
+{
+    return operator % ((uint64)u, v);
+}
+const sc_unsigned &
+sc_unsigned::operator %= (const sc_uint_base &v)
+{
+    return operator %= ((uint64)v);
+}
+
+sc_unsigned
+operator & (const sc_unsigned &u, const sc_uint_base &v)
+{
+    return operator & (u, (uint64)v);
+}
+sc_unsigned
+operator & (const sc_uint_base &u, const sc_unsigned &v)
+{
+    return operator & ((uint64)u, v);
+}
+const sc_unsigned &
+sc_unsigned::operator &= (const sc_uint_base &v)
+{
+    return operator &= ((uint64)v);
+}
+
+sc_unsigned
+operator | (const sc_unsigned &u, const sc_uint_base &v)
+{
+    return operator | (u, (uint64)v);
+}
+sc_unsigned
+operator | (const sc_uint_base &u, const sc_unsigned &v)
+{
+    return operator | ((uint64)u, v);
+}
+const sc_unsigned &
+sc_unsigned::operator |= (const sc_uint_base &v)
+{
+    return operator |= ((uint64)v);
+}
+
+sc_unsigned
+operator ^ (const sc_unsigned &u, const sc_uint_base &v)
+{
+    return operator ^ (u, (uint64)v);
+}
+sc_unsigned
+operator ^ (const sc_uint_base &u, const sc_unsigned &v)
+{
+    return operator ^ ((uint64)u, v);
+}
+const sc_unsigned &
+sc_unsigned::operator ^= (const sc_uint_base &v)
+{
+    return operator ^= ((uint64)v);
+}
+
+sc_unsigned
+operator << (const sc_unsigned &u, const sc_uint_base &v)
+{
+    return operator << (u, (uint64)v);
+}
+const sc_unsigned &
+sc_unsigned::operator <<= (const sc_uint_base &v)
+{
+    return operator <<= ((uint64)v);
+}
+
+sc_unsigned
+operator >> (const sc_unsigned &u, const sc_uint_base &v)
+{
+    return operator >> (u, (uint64)v);
+}
+const sc_unsigned &
+sc_unsigned::operator >>= (const sc_uint_base &v)
+{
+    return operator >>= ((uint64)v);
+}
+
+bool
+operator == (const sc_unsigned &u, const sc_uint_base &v)
+{
+    return operator == (u, (uint64)v);
+}
+bool
+operator == (const sc_uint_base &u, const sc_unsigned &v)
+{
+    return operator == ((uint64)u, v);
+}
+
+bool
+operator != (const sc_unsigned &u, const sc_uint_base &v)
+{
+    return operator != (u, (uint64)v);
+}
+bool
+operator != (const sc_uint_base &u, const sc_unsigned &v)
+{
+    return operator != ((uint64)u, v);
+}
+
+bool
+operator < (const sc_unsigned &u, const sc_uint_base &v)
+{
+    return operator < (u, (uint64)v);
+}
+bool
+operator < (const sc_uint_base &u, const sc_unsigned &v)
+{
+    return operator < ((uint64)u, v);
+}
+
+bool
+operator <= (const sc_unsigned &u, const sc_uint_base &v)
+{
+    return operator <= (u, (uint64)v);
+}
+bool
+operator <= (const sc_uint_base &u, const sc_unsigned &v)
+{
+    return operator <= ((uint64)u, v);
+}
+
+bool
+operator > (const sc_unsigned &u, const sc_uint_base &v)
+{
+    return operator > (u, (uint64)v);
+}
+bool
+operator > (const sc_uint_base &u, const sc_unsigned &v)
+{
+    return operator > ((uint64)u, v);
+}
+
+bool
+operator >= (const sc_unsigned &u, const sc_uint_base &v)
+{
+    return operator >= (u, (uint64)v);
+}
+bool
+operator >= (const sc_uint_base &u, const sc_unsigned &v)
+{
+    return operator >= ((uint64)u, v);
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Input and output operators
+// ----------------------------------------------------------------------------
+
+// The operators in this section are included from sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Operator macros.
+// ----------------------------------------------------------------------------
+
+#define CONVERT_LONG(u) \
+small_type u ## s = get_sign(u); \
+sc_digit u ## d[DIGITS_PER_ULONG]; \
+from_uint(DIGITS_PER_ULONG, u ## d, (unsigned long) u);
+
+#define CONVERT_LONG_2(u) \
+sc_digit u ## d[DIGITS_PER_ULONG]; \
+from_uint(DIGITS_PER_ULONG, u ## d, (unsigned long) u);
+
+#define CONVERT_INT(u) \
+small_type u ## s = get_sign(u); \
+sc_digit u ## d[DIGITS_PER_UINT]; \
+from_uint(DIGITS_PER_UINT, u ## d, (unsigned int) u);
+
+#define CONVERT_INT_2(u) \
+sc_digit u ## d[DIGITS_PER_UINT]; \
+from_uint(DIGITS_PER_UINT, u ## d, (unsigned int) u);
+
+#define CONVERT_INT64(u) \
+small_type u ## s = get_sign(u); \
+sc_digit u ## d[DIGITS_PER_UINT64]; \
+from_uint(DIGITS_PER_UINT64, u ## d, (uint64) u);
+
+#define CONVERT_INT64_2(u) \
+sc_digit u ## d[DIGITS_PER_UINT64]; \
+from_uint(DIGITS_PER_UINT64, u ## d, (uint64) u);
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: PLUS operators: +, +=, ++
+// ----------------------------------------------------------------------------
+
+// Cases to consider when computing u + v:
+// 1. 0 + v = v
+// 2. u + 0 = u
+// 3. if sgn(u) == sgn(v)
+//    3.1 u + v = +(u + v) = sgn(u) * (u + v)
+//    3.2 (-u) + (-v) = -(u + v) = sgn(u) * (u + v)
+// 4. if sgn(u) != sgn(v)
+//    4.1 u + (-v) = u - v = sgn(u) * (u - v)
+//    4.2 (-u) + v = -(u - v) ==> sgn(u) * (u - v)
+//
+// Specialization of above cases for computing ++u or u++:
+// 1. 0 + 1 = 1
+// 3. u + 1 = u + 1 = sgn(u) * (u + 1)
+// 4. (-u) + 1 = -(u - 1) = sgn(u) * (u - 1)
+
+sc_unsigned
+operator + (const sc_unsigned &u, const sc_unsigned &v)
+{
+    if (u.sgn == SC_ZERO) // case 1
+        return sc_unsigned(v);
+
+    if (v.sgn == SC_ZERO) // case 2
+        return sc_unsigned(u);
+
+    // cases 3 and 4
+    return add_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                               v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_unsigned
+operator + (const sc_unsigned &u, uint64 v)
+{
+    if (v == 0) // case 2
+        return sc_unsigned(u);
+
+    CONVERT_INT64(v);
+
+    if (u.sgn == SC_ZERO)    // case 1
+        return sc_unsigned(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
+
+    // cases 3 and 4
+    return add_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                               vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+}
+
+
+sc_unsigned
+operator + (uint64 u, const sc_unsigned &v)
+{
+    if (u == 0) // case 1
+        return sc_unsigned(v);
+
+    CONVERT_INT64(u);
+
+    if (v.sgn == SC_ZERO) // case 2
+        return sc_unsigned(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
+
+    // cases 3 and 4
+    return add_unsigned_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                               v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_unsigned
+operator + (const sc_unsigned &u, unsigned long v)
+{
+    if (v == 0) // case 2
+        return sc_unsigned(u);
+
+    CONVERT_LONG(v);
+
+    if (u.sgn == SC_ZERO) // case 1
+        return sc_unsigned(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
+
+    // cases 3 and 4
+    return add_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                               vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+}
+
+
+sc_unsigned
+operator + (unsigned long u, const sc_unsigned &v)
+{
+    if (u == 0) // case 1
+        return sc_unsigned(v);
+
+    CONVERT_LONG(u);
+
+    if (v.sgn == SC_ZERO) // case 2
+        return sc_unsigned(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
+
+    // cases 3 and 4
+    return add_unsigned_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                               v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+// The rest of the operators in this section are included from
+// sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: MINUS operators: -, -=, --
+// ----------------------------------------------------------------------------
+
+// Cases to consider when computing u + v:
+// 1. u - 0 = u
+// 2. 0 - v = -v
+// 3. if sgn(u) != sgn(v)
+//    3.1 u - (-v) = u + v = sgn(u) * (u + v)
+//    3.2 (-u) - v = -(u + v) ==> sgn(u) * (u + v)
+// 4. if sgn(u) == sgn(v)
+//    4.1 u - v = +(u - v) = sgn(u) * (u - v)
+//    4.2 (-u) - (-v) = -(u - v) = sgn(u) * (u - v)
+//
+// Specialization of above cases for computing --u or u--:
+// 1. 0 - 1 = -1
+// 3. (-u) - 1 = -(u + 1) = sgn(u) * (u + 1)
+// 4. u - 1 = u - 1 = sgn(u) * (u - 1)
+
+// The operators in this section are included from sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: MULTIPLICATION operators: *, *=
+// ----------------------------------------------------------------------------
+
+// Cases to consider when computing u * v:
+// 1. u * 0 = 0 * v = 0
+// 2. 1 * v = v and -1 * v = -v
+// 3. u * 1 = u and u * -1 = -u
+// 4. u * v = u * v
+
+sc_unsigned
+operator * (const sc_unsigned &u, const sc_unsigned &v)
+{
+    small_type s = mul_signs(u.sgn, v.sgn);
+
+    if (s == SC_ZERO) // case 1
+        return sc_unsigned();
+
+    // cases 2-4
+    return mul_unsigned_friend(s, u.nbits, u.ndigits, u.digit,
+                               v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_unsigned
+operator * (const sc_unsigned &u, uint64 v)
+{
+    small_type s = mul_signs(u.sgn, get_sign(v));
+
+    if (s == SC_ZERO) // case 1
+        return sc_unsigned();
+
+    CONVERT_INT64_2(v);
+
+    // cases 2-4
+    return mul_unsigned_friend(s, u.nbits, u.ndigits, u.digit,
+                               BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+}
+
+
+sc_unsigned
+operator * (uint64 u, const sc_unsigned &v)
+{
+    small_type s = mul_signs(v.sgn, get_sign(u));
+
+    if (s == SC_ZERO) // case 1
+        return sc_unsigned();
+
+    CONVERT_INT64_2(u);
+
+    // cases 2-4
+    return mul_unsigned_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                               v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_unsigned
+operator * (const sc_unsigned &u, unsigned long v)
+{
+    small_type s = mul_signs(u.sgn, get_sign(v));
+
+    if (s == SC_ZERO) // case 1
+        return sc_unsigned();
+
+    CONVERT_LONG_2(v);
+
+    // else cases 2-4
+    return mul_unsigned_friend(s, u.nbits, u.ndigits, u.digit,
+                               BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+}
+
+sc_unsigned
+operator * (unsigned long u, const sc_unsigned &v)
+{
+    small_type s = mul_signs(v.sgn, get_sign(u));
+
+    if (s == SC_ZERO) // case 1
+        return sc_unsigned();
+
+    CONVERT_LONG_2(u);
+
+    // cases 2-4
+    return mul_unsigned_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                               v.nbits, v.ndigits, v.digit);
+}
+
+// The rest of the operators in this section are included from
+// sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: DIVISION operators: /, /=
+// ----------------------------------------------------------------------------
+
+// Cases to consider when finding the quotient q = floor(u/v):
+// Note that u = q * v + r for r < q.
+// 1. 0 / 0 or u / 0 => error
+// 2. 0 / v => 0 = 0 * v + 0
+// 3. u / v & &u = v => u = 1 * u + 0  - u or v can be 1 or -1
+// 4. u / v & &u < v => u = 0 * v + u  - u can be 1 or -1
+// 5. u / v & &u > v => u = q * v + r  - v can be 1 or -1
+
+sc_unsigned
+operator / (const sc_unsigned &u, const sc_unsigned &v)
+{
+    small_type s = mul_signs(u.sgn, v.sgn);
+
+    if (s == SC_ZERO) {
+        div_by_zero(v.sgn); // case 1
+        return sc_unsigned(); // case 2
+    }
+
+    // other cases
+    return div_unsigned_friend(s, u.nbits, u.ndigits, u.digit,
+                               v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_unsigned
+operator / (const sc_unsigned &u, uint64 v)
+{
+    small_type s = mul_signs(u.sgn, get_sign(v));
+
+    if (s == SC_ZERO) {
+        div_by_zero(v); // case 1
+        return sc_unsigned(); // case 2
+    }
+
+    CONVERT_INT64_2(v);
+
+    // other cases
+    return div_unsigned_friend(s, u.nbits, u.ndigits, u.digit,
+                               BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+}
+
+
+sc_unsigned
+operator / (uint64 u, const sc_unsigned &v)
+{
+    small_type s = mul_signs(v.sgn, get_sign(u));
+
+    if (s == SC_ZERO) {
+        div_by_zero(v.sgn); // case 1
+        return sc_unsigned(); // case 2
+
+    }
+
+    CONVERT_INT64_2(u);
+
+    // other cases
+    return div_unsigned_friend(s, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                               v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_unsigned
+operator / (const sc_unsigned &u, unsigned long v)
+{
+    small_type s = mul_signs(u.sgn, get_sign(v));
+
+    if (s == SC_ZERO) {
+        div_by_zero(v); // case 1
+        return sc_unsigned(); // case 2
+    }
+
+    CONVERT_LONG_2(v);
+
+    // other cases
+    return div_unsigned_friend(s, u.nbits, u.ndigits, u.digit,
+                               BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+}
+
+
+sc_unsigned
+operator / (unsigned long u, const sc_unsigned &v)
+{
+    small_type s = mul_signs(v.sgn, get_sign(u));
+
+    if (s == SC_ZERO) {
+        div_by_zero(v.sgn); // case 1
+        return sc_unsigned(); // case 2
+
+    }
+
+    CONVERT_LONG_2(u);
+
+    // other cases
+    return div_unsigned_friend(s, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                               v.nbits, v.ndigits, v.digit);
+}
+
+// The rest of the operators in this section are included from
+// sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: MOD operators: %, %=.
+// ----------------------------------------------------------------------------
+
+// Cases to consider when finding the remainder r = u % v:
+// Note that u = q * v + r for r < q.
+// 1. 0 % 0 or u % 0 => error
+// 2. 0 % v => 0 = 0 * v + 0
+// 3. u % v & &u = v => u = 1 * u + 0  - u or v can be 1 or -1
+// 4. u % v & &u < v => u = 0 * v + u  - u can be 1 or -1
+// 5. u % v & &u > v => u = q * v + r  - v can be 1 or -1
+
+sc_unsigned
+operator % (const sc_unsigned &u, const sc_unsigned &v)
+{
+    if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) {
+        div_by_zero(v.sgn); // case 1
+        return sc_unsigned(); // case 2
+    }
+
+    // other cases
+    return mod_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                               v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_unsigned
+operator % (const sc_unsigned &u, uint64 v)
+{
+    if ((u.sgn == SC_ZERO) || (v == 0)) {
+        div_by_zero(v); // case 1
+        return sc_unsigned(); // case 2
+    }
+
+    CONVERT_INT64_2(v);
+
+    // other cases
+    return mod_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                               BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+
+}
+
+
+sc_unsigned
+operator % (uint64 u, const sc_unsigned &v)
+{
+    if ((u == 0) || (v.sgn == SC_ZERO)) {
+        div_by_zero(v.sgn); // case 1
+        return sc_unsigned(); // case 2
+    }
+
+    CONVERT_INT64(u);
+
+    // other cases
+    return mod_unsigned_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                               v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_unsigned
+operator % (const sc_unsigned &u, unsigned long v)
+{
+    if ((u.sgn == SC_ZERO) || (v == 0)) {
+        div_by_zero(v); // case 1
+        return sc_unsigned(); // case 2
+    }
+
+    CONVERT_LONG_2(v);
+
+    // other cases
+    return mod_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                               BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+}
+
+
+sc_unsigned
+operator % (unsigned long u, const sc_unsigned &v)
+{
+    if ((u == 0) || (v.sgn == SC_ZERO)) {
+        div_by_zero(v.sgn); // case 1
+        return sc_unsigned(); // case 2
+    }
+
+    CONVERT_LONG(u);
+
+    // other cases
+    return mod_unsigned_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                               v.nbits, v.ndigits, v.digit);
+}
+
+// The rest of the operators in this section are included from
+// sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Bitwise AND operators: &, &=
+// ----------------------------------------------------------------------------
+
+// Cases to consider when computing u  &v:
+// 1. u & 0 = 0  &v = 0
+// 2. u  &v => sgn = +
+// 3. (-u) & (-v) => sgn = -
+// 4. u & (-v) => sgn = +
+// 5. (-u)  &v => sgn = +
+
+sc_unsigned
+operator & (const sc_unsigned &u, const sc_unsigned &v)
+{
+    if ((u.sgn == SC_ZERO) || (v.sgn == SC_ZERO)) // case 1
+        return sc_unsigned();
+
+    // other cases
+    return and_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                               v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_unsigned
+operator & (const sc_unsigned &u, uint64 v)
+{
+    if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
+        return sc_unsigned();
+
+    CONVERT_INT64(v);
+
+    // other cases
+    return and_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                               vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+}
+
+
+sc_unsigned
+operator & (uint64 u, const sc_unsigned &v)
+{
+    if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
+        return sc_unsigned();
+
+    CONVERT_INT64(u);
+
+    // other cases
+    return and_unsigned_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                               v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_unsigned
+operator & (const sc_unsigned &u, unsigned long v)
+{
+    if ((u.sgn == SC_ZERO) || (v == 0)) // case 1
+        return sc_unsigned();
+
+    CONVERT_LONG(v);
+
+    // other cases
+    return and_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                               vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+}
+
+
+sc_unsigned
+operator & (unsigned long u, const sc_unsigned &v)
+{
+    if ((u == 0) || (v.sgn == SC_ZERO)) // case 1
+        return sc_unsigned();
+
+    CONVERT_LONG(u);
+
+    // other cases
+    return and_unsigned_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                               v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+// The rest of the operators in this section are included from
+// sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Bitwise OR operators: |, |=
+// ----------------------------------------------------------------------------
+
+// Cases to consider when computing u | v:
+// 1. u | 0 = u
+// 2. 0 | v = v
+// 3. u | v => sgn = +
+// 4. (-u) | (-v) => sgn = -
+// 5. u | (-v) => sgn = -
+// 6. (-u) | v => sgn = -
+
+sc_unsigned
+operator | (const sc_unsigned &u, const sc_unsigned &v)
+{
+    if (v.sgn == SC_ZERO) // case 1
+        return sc_unsigned(u);
+
+    if (u.sgn == SC_ZERO) // case 2
+        return sc_unsigned(v);
+
+    // other cases
+    return or_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                              v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_unsigned
+operator | (const sc_unsigned &u, uint64 v)
+{
+    if (v == 0) // case 1
+        return sc_unsigned(u);
+
+    CONVERT_INT64(v);
+
+    if (u.sgn == SC_ZERO) // case 2
+        return sc_unsigned(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
+
+    // other cases
+    return or_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                              vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+}
+
+
+sc_unsigned
+operator | (uint64 u, const sc_unsigned &v)
+{
+    if (u == 0)
+        return sc_unsigned(v);
+
+    CONVERT_INT64(u);
+
+    if (v.sgn == SC_ZERO)
+        return sc_unsigned(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
+
+    // other cases
+    return or_unsigned_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                              v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_unsigned
+operator | (const sc_unsigned &u, unsigned long v)
+{
+    if (v == 0) // case 1
+        return sc_unsigned(u);
+
+    CONVERT_LONG(v);
+
+    if (u.sgn == SC_ZERO) // case 2
+        return sc_unsigned(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
+
+    // other cases
+    return or_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                              vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+}
+
+
+sc_unsigned
+operator | (unsigned long u, const sc_unsigned &v)
+{
+    if (u == 0)
+        return sc_unsigned(v);
+
+    CONVERT_LONG(u);
+
+    if (v.sgn == SC_ZERO)
+        return sc_unsigned(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
+
+    // other cases
+    return or_unsigned_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                              v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+// The rest of the operators in this section are included from
+// sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Bitwise XOR operators: ^, ^=
+// ----------------------------------------------------------------------------
+
+// Cases to consider when computing u ^ v:
+// Note that  u ^ v = (~u  &v) | (u & ~v).
+// 1. u ^ 0 = u
+// 2. 0 ^ v = v
+// 3. u ^ v => sgn = +
+// 4. (-u) ^ (-v) => sgn = -
+// 5. u ^ (-v) => sgn = -
+// 6. (-u) ^ v => sgn = +
+
+sc_unsigned
+operator ^ (const sc_unsigned &u, const sc_unsigned &v)
+{
+    if (v.sgn == SC_ZERO) // case 1
+        return sc_unsigned(u);
+
+    if (u.sgn == SC_ZERO) // case 2
+        return sc_unsigned(v);
+
+    // other cases
+    return xor_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                               v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_unsigned
+operator ^ (const sc_unsigned &u, uint64 v)
+{
+    if (v == 0) // case 1
+        return sc_unsigned(u);
+
+    CONVERT_INT64(v);
+
+    if (u.sgn == SC_ZERO) // case 2
+        return sc_unsigned(vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd, false);
+
+    // other cases
+    return xor_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                               vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd);
+}
+
+sc_unsigned
+operator ^ (uint64 u, const sc_unsigned &v)
+{
+    if (u == 0)
+        return sc_unsigned(v);
+
+    CONVERT_INT64(u);
+
+    if (v.sgn == SC_ZERO)
+        return sc_unsigned(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud, false);
+
+    // other cases
+    return xor_unsigned_friend(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                               v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+
+sc_unsigned
+operator ^ (const sc_unsigned &u, unsigned long v)
+{
+    if (v == 0) // case 1
+        return sc_unsigned(u);
+
+    CONVERT_LONG(v);
+
+    if (u.sgn == SC_ZERO) // case 2
+        return sc_unsigned(vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd, false);
+
+    // other cases
+    return xor_unsigned_friend(u.sgn, u.nbits, u.ndigits, u.digit,
+                               vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd);
+}
+
+sc_unsigned
+operator ^ (unsigned long u, const sc_unsigned &v)
+{
+    if (u == 0)
+        return sc_unsigned(v);
+
+    CONVERT_LONG(u);
+
+    if (v.sgn == SC_ZERO)
+        return sc_unsigned(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud, false);
+
+    // other cases
+    return xor_unsigned_friend(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                               v.sgn, v.nbits, v.ndigits, v.digit);
+}
+
+// The rest of the operators in this section are included from
+// sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Bitwise NOT operator: ~
+// ----------------------------------------------------------------------------
+
+// Operators in this section are included from sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: LEFT SHIFT operators: <<, <<=
+// ----------------------------------------------------------------------------
+
+sc_unsigned
+operator << (const sc_unsigned &u, const sc_signed &v)
+{
+    if ((v.sgn == SC_ZERO) || (v.sgn == SC_NEG))
+        return sc_unsigned(u);
+
+    return operator << (u, v.to_ulong());
+}
+
+// The rest of the operators in this section are included from
+// sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//    SECTION: RIGHT SHIFT operators: >>, >>=
+// ----------------------------------------------------------------------------
+
+sc_unsigned
+operator >> (const sc_unsigned &u, const sc_signed &v)
+{
+
+    if ((v.sgn == SC_ZERO) || (v.sgn == SC_NEG))
+        return sc_unsigned(u);
+
+    return operator >> (u, v.to_long());
+
+}
+
+// The rest of the operators in this section are included from
+// sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//    SECTION: Unary arithmetic operators.
+// ----------------------------------------------------------------------------
+
+sc_unsigned
+operator + (const sc_unsigned &u)
+{
+    return sc_unsigned(u);
+}
+
+
+// ----------------------------------------------------------------------------
+//    SECTION: EQUAL operator: ==
+// ----------------------------------------------------------------------------
+
+bool
+operator == (const sc_unsigned &u, const sc_unsigned &v)
+{
+    if (&u == &v)
+        return true;
+    if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit,
+                         v.sgn, v.nbits, v.ndigits, v.digit) != 0) {
+        return false;
+    }
+    return true;
+}
+
+
+bool
+operator == (const sc_unsigned &u, const sc_signed &v)
+{
+    if (v.sgn == SC_NEG)
+        return false;
+    if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit,
+                         v.sgn, v.nbits, v.ndigits, v.digit, 0, 1) != 0) {
+        return false;
+    }
+    return true;
+}
+
+
+bool
+operator == (const sc_signed &u, const sc_unsigned &v)
+{
+    if (u.sgn == SC_NEG)
+        return false;
+    if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit,
+                         v.sgn, v.nbits, v.ndigits, v.digit, 1, 0) != 0) {
+        return false;
+    }
+    return true;
+}
+
+
+bool
+operator == (const sc_unsigned &u, int64 v)
+{
+    if (v < 0)
+        return false;
+    CONVERT_INT64(v);
+    if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit,
+                         vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd) != 0) {
+        return false;
+    }
+    return true;
+}
+
+
+bool
+operator == (int64 u, const sc_unsigned &v)
+{
+    if (u < 0)
+        return false;
+    CONVERT_INT64(u);
+    if (compare_unsigned(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                         v.sgn, v.nbits, v.ndigits, v.digit) != 0) {
+        return false;
+    }
+    return true;
+}
+
+
+bool
+operator == (const sc_unsigned &u, uint64 v)
+{
+    CONVERT_INT64(v);
+    if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit,
+                         vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd) != 0)
+        return false;
+    return true;
+}
+
+
+bool
+operator == (uint64 u, const sc_unsigned &v)
+{
+    CONVERT_INT64(u);
+    if (compare_unsigned(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                         v.sgn, v.nbits, v.ndigits, v.digit) != 0)
+        return false;
+    return true;
+}
+
+
+bool
+operator == (const sc_unsigned &u, long v)
+{
+    if (v < 0)
+        return false;
+    CONVERT_LONG(v);
+    if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit,
+                         vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd) != 0)
+        return false;
+    return true;
+}
+
+
+bool
+operator == (long u, const sc_unsigned &v)
+{
+    if (u < 0)
+        return false;
+    CONVERT_LONG(u);
+    if (compare_unsigned(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                         v.sgn, v.nbits, v.ndigits, v.digit) != 0)
+        return false;
+    return true;
+}
+
+
+bool
+operator == (const sc_unsigned &u, unsigned long v)
+{
+    CONVERT_LONG(v);
+    if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit,
+                         vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd) != 0)
+        return false;
+    return true;
+}
+
+
+bool
+operator == (unsigned long u, const sc_unsigned &v)
+{
+    CONVERT_LONG(u);
+    if (compare_unsigned(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                         v.sgn, v.nbits, v.ndigits, v.digit) != 0)
+        return false;
+    return true;
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: NOT_EQUAL operator: !=
+// ----------------------------------------------------------------------------
+
+bool
+operator != (const sc_unsigned &u, const sc_signed &v)
+{
+    return (!operator == (u, v));
+}
+
+
+bool
+operator != (const sc_signed &u, const sc_unsigned &v)
+{
+    return (!operator == (u, v));
+}
+
+// The rest of the operators in this section are included from sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: LESS THAN operator: <
+// ----------------------------------------------------------------------------
+
+bool
+operator < (const sc_unsigned &u, const sc_unsigned &v)
+{
+    if (&u == &v)
+        return false;
+    if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit,
+                         v.sgn, v.nbits, v.ndigits, v.digit) < 0) {
+        return true;
+    }
+    return false;
+}
+
+
+bool
+operator < (const sc_unsigned &u, const sc_signed &v)
+{
+    if (v.sgn == SC_NEG)
+        return false;
+    if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit,
+                         v.sgn, v.nbits, v.ndigits, v.digit, 0, 1) < 0) {
+        return true;
+    }
+    return false;
+}
+
+
+bool
+operator < (const sc_signed &u, const sc_unsigned &v)
+{
+    if (u.sgn == SC_NEG)
+        return true;
+    if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit,
+                       v.sgn, v.nbits, v.ndigits, v.digit, 1, 0) < 0) {
+        return true;
+    }
+    return false;
+}
+
+
+bool
+operator < (const sc_unsigned &u, int64 v)
+{
+    if (v < 0)
+        return false;
+    CONVERT_INT64(v);
+    if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit,
+                         vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd) < 0) {
+        return true;
+    }
+    return false;
+}
+
+
+bool
+operator < (int64 u, const sc_unsigned &v)
+{
+    if (u < 0)
+        return true;
+    CONVERT_INT64(u);
+    if (compare_unsigned(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                         v.sgn, v.nbits, v.ndigits, v.digit) < 0) {
+        return true;
+    }
+    return false;
+}
+
+
+bool
+operator < (const sc_unsigned &u, uint64 v)
+{
+    CONVERT_INT64(v);
+    if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit,
+                         vs, BITS_PER_UINT64, DIGITS_PER_UINT64, vd) < 0) {
+        return true;
+    }
+    return false;
+}
+
+
+bool
+operator < (uint64 u, const sc_unsigned &v)
+{
+    CONVERT_INT64(u);
+    if (compare_unsigned(us, BITS_PER_UINT64, DIGITS_PER_UINT64, ud,
+                         v.sgn, v.nbits, v.ndigits, v.digit) < 0){
+        return true;
+    }
+    return false;
+}
+
+
+bool
+operator < (const sc_unsigned &u, long v)
+{
+    if (v < 0)
+        return false;
+    CONVERT_LONG(v);
+    if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit,
+                         vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd) < 0) {
+        return true;
+    }
+    return false;
+}
+
+
+bool
+operator < (long u, const sc_unsigned &v)
+{
+    if (u < 0)
+        return true;
+    CONVERT_LONG(u);
+    if (compare_unsigned(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                         v.sgn, v.nbits, v.ndigits, v.digit) < 0) {
+        return true;
+    }
+    return false;
+}
+
+
+bool
+operator < (const sc_unsigned &u, unsigned long v)
+{
+    CONVERT_LONG(v);
+    if (compare_unsigned(u.sgn, u.nbits, u.ndigits, u.digit,
+                         vs, BITS_PER_ULONG, DIGITS_PER_ULONG, vd) < 0) {
+        return true;
+    }
+    return false;
+}
+
+
+bool
+operator < (unsigned long u, const sc_unsigned &v)
+{
+    CONVERT_LONG(u);
+    if (compare_unsigned(us, BITS_PER_ULONG, DIGITS_PER_ULONG, ud,
+                         v.sgn, v.nbits, v.ndigits, v.digit) < 0) {
+        return true;
+    }
+    return false;
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: LESS THAN or EQUAL operator: <=
+// ----------------------------------------------------------------------------
+
+bool
+operator <= (const sc_unsigned &u, const sc_signed &v)
+{
+    return (operator < (u, v) || operator == (u, v));
+}
+
+
+bool
+operator <= (const sc_signed &u, const sc_unsigned &v)
+{
+    return (operator < (u, v) || operator == (u, v));
+}
+
+// The rest of the operators in this section are included from sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: GREATER THAN operator: >
+// ----------------------------------------------------------------------------
+
+bool
+operator > (const sc_unsigned &u, const sc_signed &v)
+{
+  return (!(operator <= (u, v)));
+}
+
+
+bool
+operator > (const sc_signed &u, const sc_unsigned &v)
+{
+  return (!(operator <= (u, v)));
+}
+
+// The rest of the operators in this section are included from sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: GREATER THAN or EQUAL operator: >=
+// ----------------------------------------------------------------------------
+
+bool
+operator >= (const sc_unsigned &u, const sc_signed &v)
+{
+  return (!(operator < (u, v)));
+}
+
+
+bool
+operator >= (const sc_signed &u, const sc_unsigned &v)
+{
+  return (!(operator < (u, v)));
+}
+
+// The rest of the operators in this section are included from sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Friends
+// ----------------------------------------------------------------------------
+
+// Compare u and v as unsigned and return r
+//  r = 0 if u == v
+//  r < 0 if u < v
+//  r > 0 if u > v
+
+int
+compare_unsigned(small_type us, int unb, int und, const sc_digit *ud,
+                 small_type vs, int vnb, int vnd, const sc_digit *vd,
+                 small_type if_u_signed, small_type if_v_signed)
+{
+    if (us == vs) {
+        if (us == SC_ZERO) {
+            return 0;
+        } else {
+            int cmp_res = vec_skip_and_cmp(und, ud, vnd, vd);
+            if (us == SC_POS)
+                return cmp_res;
+            else
+                return -cmp_res;
+        }
+    } else {
+        if (us == SC_ZERO)
+            return -vs;
+        if (vs == SC_ZERO)
+            return us;
+
+        int cmp_res;
+        int nd = (us == SC_NEG ? und : vnd);
+
+#ifdef SC_MAX_NBITS
+        sc_digit d[MAX_NDIGITS];
+#else
+        sc_digit *d = new sc_digit[nd];
+#endif
+
+        if (us == SC_NEG) {
+            vec_copy(nd, d, ud);
+            vec_complement(nd, d);
+            trim(if_u_signed, unb, nd, d);
+            cmp_res = vec_skip_and_cmp(nd, d, vnd, vd);
+        } else {
+            vec_copy(nd, d, vd);
+            vec_complement(nd, d);
+            trim(if_v_signed, vnb, nd, d);
+            cmp_res = vec_skip_and_cmp(und, ud, nd, d);
+        }
+
+#ifndef SC_MAX_NBITS
+        delete [] d;
+#endif
+
+        return cmp_res;
+    }
+}
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Public members - Other utils.
+// ----------------------------------------------------------------------------
+
+bool
+sc_unsigned::iszero() const
+{
+    if (sgn == SC_ZERO) {
+        return true;
+    } else if (sgn == SC_NEG) {
+        // A negative unsigned number can be zero, e.g., -16 in 4 bits, so
+        // check that.
+
+#ifdef SC_MAX_NBITS
+        sc_digit d[MAX_NDIGITS];
+#else
+        sc_digit *d = new sc_digit[ndigits];
+#endif
+
+        vec_copy(ndigits, d, digit);
+        vec_complement(ndigits, d);
+        trim_unsigned(nbits, ndigits, d);
+
+        bool res = check_for_zero(ndigits, d);
+
+#ifndef SC_MAX_NBITS
+        delete [] d;
+#endif
+
+        return res;
+    } else {
+        return false;
+    }
+}
+
+// The rest of the utils in this section are included from sc_nbcommon.cpp.
+
+
+// ----------------------------------------------------------------------------
+//  SECTION: Private members.
+// ----------------------------------------------------------------------------
+
+// The private members in this section are included from
+// sc_nbcommon.cpp.
+
+#define CLASS_TYPE sc_unsigned
+#define CLASS_TYPE_STR "sc_unsigned"
+
+#define ADD_HELPER add_unsigned_friend
+#define SUB_HELPER sub_unsigned_friend
+#define MUL_HELPER mul_unsigned_friend
+#define DIV_HELPER div_unsigned_friend
+#define MOD_HELPER mod_unsigned_friend
+#define AND_HELPER and_unsigned_friend
+#define OR_HELPER or_unsigned_friend
+#define XOR_HELPER xor_unsigned_friend
+
+#include "sc_nbfriends.inc"
+
+#undef SC_SIGNED
+#define SC_UNSIGNED
+#define IF_SC_SIGNED 0 // 0 = sc_unsigned
+#define CLASS_TYPE_SUBREF sc_unsigned_subref_r
+#define OTHER_CLASS_TYPE sc_signed
+#define OTHER_CLASS_TYPE_SUBREF sc_signed_subref_r
+
+#define MUL_ON_HELPER mul_on_help_unsigned
+#define DIV_ON_HELPER div_on_help_unsigned
+#define MOD_ON_HELPER mod_on_help_unsigned
+
+#include "sc_nbcommon.inc"
+
+#undef MOD_ON_HELPER
+#undef DIV_ON_HELPER
+#undef MUL_ON_HELPER
+
+#undef OTHER_CLASS_TYPE_SUBREF
+#undef OTHER_CLASS_TYPE
+#undef CLASS_TYPE_SUBREF
+#undef IF_SC_SIGNED
+#undef SC_UNSIGNED
+
+#undef XOR_HELPER
+#undef OR_HELPER
+#undef AND_HELPER
+#undef MOD_HELPER
+#undef DIV_HELPER
+#undef MUL_HELPER
+#undef SUB_HELPER
+#undef ADD_HELPER
+
+#undef CLASS_TYPE
+#undef CLASS_TYPE_STR
+
+#include "sc_unsigned_bitref.inc"
+#include "sc_unsigned_subref.inc"
+
+#undef CONVERT_LONG
+#undef CONVERT_LONG_2
+#undef CONVERT_INT64
+#undef CONVERT_INT64_2
+
+} // namespace sc_dt
diff --git a/src/systemc/dt/int/sc_unsigned_bitref.inc b/src/systemc/dt/int/sc_unsigned_bitref.inc
new file mode 100644
index 0000000..09eccd0
--- /dev/null
+++ b/src/systemc/dt/int/sc_unsigned_bitref.inc
@@ -0,0 +1,162 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_unsigned_bitref.h -- Proxy class that is declared in sc_unsigned.h.  
+
+  Original Author: Ali Dasdan, Synopsys, Inc.
+ 
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_unsigned_bitref_r
+//
+//  Proxy class for sc_unsigned bit selection (r-value only).
+// ----------------------------------------------------------------------------
+
+// implicit conversion to uint64
+
+sc_unsigned_bitref_r::operator uint64 () const
+{
+    return m_obj_p->test(m_index);
+}
+
+bool
+sc_unsigned_bitref_r::operator ! () const
+{
+    return (!m_obj_p->test(m_index));
+}
+
+bool
+sc_unsigned_bitref_r::operator ~ () const
+{
+    return (!m_obj_p->test(m_index));
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_unsigned_bitref
+//
+//  Proxy class for sc_unsigned bit selection (r-value and l-value).
+// ----------------------------------------------------------------------------
+
+// assignment operators
+
+const sc_unsigned_bitref &
+sc_unsigned_bitref::operator = (const sc_unsigned_bitref_r &b)
+{
+    m_obj_p->set(m_index, (bool)b);
+    return *this;
+}
+
+const sc_unsigned_bitref &
+sc_unsigned_bitref::operator = (const sc_unsigned_bitref &b)
+{
+    m_obj_p->set(m_index, (bool)b);
+    return *this;
+}
+
+const sc_unsigned_bitref &
+sc_unsigned_bitref::operator = (bool b)
+{
+    m_obj_p->set(m_index, b);
+    return *this;
+}
+
+
+const sc_unsigned_bitref &
+sc_unsigned_bitref::operator &= (bool b)
+{
+    if (!b) {
+        m_obj_p->clear(m_index);
+    }
+    return *this;
+}
+
+const sc_unsigned_bitref &
+sc_unsigned_bitref::operator |= (bool b)
+{
+    if (b) {
+        m_obj_p->set(m_index);
+    }
+    return *this;
+}
+
+const sc_unsigned_bitref &
+sc_unsigned_bitref::operator ^= (bool b)
+{
+    if (b) {
+        m_obj_p->invert(m_index);
+    }
+    return *this;
+}
+
+// #### OPTIMIZE
+void
+sc_unsigned_bitref::concat_set(int64 src, int low_i)
+{
+    bool value = 1 & ((low_i < 64) ? (src >> low_i) : (src >> 63));
+    m_obj_p->set(low_i, value);
+}
+
+void
+sc_unsigned_bitref::concat_set(const sc_signed &src, int low_i)
+{
+    if (low_i < src.length())
+        m_obj_p->set(low_i, src.test(low_i));
+    else
+        m_obj_p->set(low_i, src < 0);
+}
+
+void
+sc_unsigned_bitref::concat_set(const sc_unsigned &src, int low_i)
+{       
+    if (low_i < src.nbits)
+        m_obj_p->set(low_i, src.test(low_i));
+    else
+        m_obj_p->set(low_i, 0);
+}
+
+void
+sc_unsigned_bitref::concat_set(uint64 src, int low_i)
+{
+    bool value = ((low_i < 64) ? (src >> low_i) & 1 : 0);
+    m_obj_p->set(low_i, value);
+}
+
+// other methods
+void
+sc_unsigned_bitref::scan(::std::istream &is)
+{
+    bool b;
+    is >> b;
+    *this = b;
+}
diff --git a/src/systemc/dt/int/sc_unsigned_subref.inc b/src/systemc/dt/int/sc_unsigned_subref.inc
new file mode 100644
index 0000000..f76f65c
--- /dev/null
+++ b/src/systemc/dt/int/sc_unsigned_subref.inc
@@ -0,0 +1,394 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_unsigned_subref.h -- Proxy class that is declared in sc_unsigned.h.
+
+  Original Author: Ali Dasdan, Synopsys, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_unsigned_subref_r
+//
+//  Proxy class for sc_unsigned part selection (r-value only).
+// ----------------------------------------------------------------------------
+
+// concatenation support
+
+uint64
+sc_unsigned_subref_r::concat_get_uint64() const // #### Speed up!
+{
+    sc_unsigned a(m_obj_p, m_left, m_right);
+    return a.to_uint64();
+}
+
+
+bool
+sc_unsigned_subref_r::concat_get_ctrl(sc_digit *dst_p, int low_i) const
+// #### Speed up!
+{
+    sc_unsigned a(m_obj_p, m_left, m_right);
+    return a.concat_get_ctrl(dst_p, low_i);
+}
+
+bool
+sc_unsigned_subref_r::concat_get_data(sc_digit *dst_p, int low_i) const
+// #### Speed up!
+{
+    sc_unsigned a(m_obj_p, m_left, m_right);
+    return a.concat_get_data(dst_p, low_i);
+}
+
+// implicit conversion to sc_unsigned
+sc_unsigned_subref_r::operator sc_unsigned () const
+{
+    return sc_unsigned(m_obj_p, m_left, m_right);
+}
+
+
+// explicit conversions
+int
+sc_unsigned_subref_r::to_int() const
+{
+    sc_unsigned a(m_obj_p, m_left, m_right);
+    return a.to_int();
+}
+
+unsigned int
+sc_unsigned_subref_r::to_uint() const
+{
+    sc_unsigned a(m_obj_p, m_left, m_right);
+    return a.to_uint();
+}
+
+long
+sc_unsigned_subref_r::to_long() const
+{
+    sc_unsigned a(m_obj_p, m_left, m_right);
+    return a.to_long();
+}
+
+unsigned long
+sc_unsigned_subref_r::to_ulong() const
+{
+    sc_unsigned a(m_obj_p, m_left, m_right);
+    return a.to_ulong();
+}
+
+int64
+sc_unsigned_subref_r::to_int64() const
+{
+    sc_unsigned a(m_obj_p, m_left, m_right);
+    return a.to_int64();
+}
+
+uint64
+sc_unsigned_subref_r::to_uint64() const
+{
+    sc_unsigned a(m_obj_p, m_left, m_right);
+    return a.to_uint64();
+}
+
+double
+sc_unsigned_subref_r::to_double() const
+{
+    sc_unsigned a(m_obj_p, m_left, m_right);
+    return a.to_double();
+}
+
+
+// explicit conversion to character string
+const std::string
+sc_unsigned_subref_r::to_string(sc_numrep numrep) const
+{
+    sc_unsigned a(length());
+    a = *this;
+    return a.to_string(numrep);
+}
+
+const std::string
+sc_unsigned_subref_r::to_string(sc_numrep numrep, bool w_prefix) const
+{
+    sc_unsigned a(length());
+    a = *this;
+    return a.to_string(numrep, w_prefix);
+}
+
+
+// ----------------------------------------------------------------------------
+//  CLASS : sc_unsigned_subref
+//
+//  Proxy class for sc_unsigned part selection (r-value and l-value).
+// ----------------------------------------------------------------------------
+
+// assignment operators
+
+const sc_unsigned_subref &
+sc_unsigned_subref::operator = (const sc_unsigned_subref_r &a)
+{
+    return operator = ((sc_unsigned)(a));
+}
+
+const sc_unsigned_subref &
+sc_unsigned_subref::operator = (const sc_unsigned_subref &a)
+{
+    if (this == &a) {
+        return *this;
+    }
+    return operator = ((sc_unsigned)(a));
+}
+
+const sc_unsigned_subref &
+sc_unsigned_subref::operator = (const sc_unsigned &v)
+{
+    int i;
+    int l = sc_min(m_left, v.nbits - 1 + m_right);
+
+    for (i = m_right; i <= l; ++i)
+        m_obj_p->set(i, v.test(i - m_right));
+    for (; i <= m_left; i++)
+        m_obj_p->set(i, v.test(l));
+    return *this;
+}
+
+const sc_unsigned_subref &
+sc_unsigned_subref::operator = (const sc_signed_subref_r &v)
+{
+    return operator = ((sc_unsigned)(v));
+}
+
+const sc_unsigned_subref &
+sc_unsigned_subref::operator = (const sc_signed &v)
+{
+    int i;
+    int l = sc_min(m_left, v.nbits - 1 + m_right);
+
+    for (i = m_right; i <= l; ++i)
+        m_obj_p->set(i, v.test(i - m_right));
+    for (; i <= m_left; i++)
+        m_obj_p->set(i, 0);
+    return *this;
+}
+
+const sc_unsigned_subref &
+sc_unsigned_subref::operator = (unsigned long v)
+{
+    for (int i = m_right; i <= m_left; ++i) {
+        m_obj_p->set(i, static_cast<bool>(v & 1));
+        v >>= 1;
+    }
+    return *this;
+}
+
+const sc_unsigned_subref &
+sc_unsigned_subref::operator = (long v)
+{
+    unsigned long v2 = (unsigned long)v;
+    for (int i = m_right; i <= m_left; ++i) {
+        m_obj_p->set(i, static_cast<bool>(v2 & 1));
+        v2 >>= 1;
+    }
+    return *this;
+}
+
+const sc_unsigned_subref &
+sc_unsigned_subref::operator = (uint64 v)
+{
+    for (int i = m_right; i <= m_left; ++i) {
+        m_obj_p->set(i, static_cast<bool>(v & 1));
+        v >>= 1;
+    }
+    return *this;
+}
+
+const sc_unsigned_subref &
+sc_unsigned_subref::operator = (int64 v)
+{
+    uint64 v2 = (uint64)v;
+    for (int i = m_right; i <= m_left; ++i) {
+        m_obj_p->set(i, static_cast<bool>(v2 & 1));
+        v2 >>= 1;
+    }
+    return *this;
+}
+
+const sc_unsigned_subref &
+sc_unsigned_subref::operator = (double v)
+{
+    is_bad_double(v);
+
+    int nb = m_left - m_right + 1;
+    int nd = DIV_CEIL(nb);
+
+#ifdef SC_MAX_NBITS
+    sc_digit d[MAX_NDIGITS];
+#else
+    sc_digit *d = new sc_digit[nd];
+#endif
+
+    if (v < 0)
+        v = -v;
+
+    int i = 0;
+    while (std::floor(v) && (i < nd)) {
+        d[i++] = (sc_digit) std::floor(remainder(v, DIGIT_RADIX));
+        v /= DIGIT_RADIX;
+    }
+    vec_zero(i, nd, d);
+
+    sc_digit val = 1; // Bit value.
+    int j = 0; // Current digit in d.
+
+    i = 0; // Current bit in d.
+    while (i < nb) {
+        m_obj_p->set(i + m_right, (bool)(d[j] & val));
+        ++i;
+        if (i % BITS_PER_DIGIT == 0) {
+            val = 1;
+            ++j;
+        } else {
+            val <<= 1;
+        }
+    }
+#ifndef SC_MAX_NBITS
+    delete [] d;
+#endif
+    return *this;
+}
+
+const sc_unsigned_subref &
+sc_unsigned_subref::operator = (const sc_int_base &a)
+{
+    return operator = ((int64)a);
+}
+
+const sc_unsigned_subref &
+sc_unsigned_subref::operator = (const sc_uint_base &a)
+{
+    return operator = ((uint64)a);
+}
+
+// concatenation methods
+void
+sc_unsigned_subref::concat_set(int64 src, int low_i)
+{
+    int i;
+    int l;
+    bool sign = src < 0;
+
+    if (low_i < 64) {
+        src = src >> low_i;
+        l = sc_min(m_left, (63 - low_i) + m_right);
+        for (i = m_right; i <= l; ++i) {
+            m_obj_p->set(i, src & 1);
+            src = src >> 1;
+        }
+        for (; i <= m_left; i++)
+            m_obj_p->set(sign);
+    } else {
+        for (i = m_right; i <= m_left; ++i)
+            m_obj_p->set(sign);
+    }
+}
+
+void
+sc_unsigned_subref::concat_set(const sc_signed &src, int low_i)
+{
+    int i;
+    int l;
+    int src_i;
+    bool sign = src.test(src.nbits - 1);
+    l = src.nbits - (low_i + 1);
+    if (l >= 0) {
+        src_i = low_i;
+        l = sc_min(m_left, l + m_right);
+        for (i = m_right; i <= l; ++i, src_i++) {
+            m_obj_p->set(i, src.test(src_i));
+        }
+        for (; i <= m_left; i++)
+            m_obj_p->set(i, sign);
+    } else {
+        for (i = m_right; i <= m_left; ++i)
+            m_obj_p->set(i, sign);
+    }
+}
+
+void
+sc_unsigned_subref::concat_set(const sc_unsigned &src, int low_i)
+{
+    int i;
+    int l;
+    int src_i;
+    l = src.nbits - (low_i + 2);
+    if (l >= 0) {
+        src_i = low_i;
+        l = sc_min(m_left, l + m_right);
+        for (i = m_right; i <= l; ++i, src_i++) {
+            m_obj_p->set(i, src.test(src_i));
+        }
+        for (; i <= m_left; i++)
+            m_obj_p->set(i, false);
+    } else {
+        for (i = m_right; i <= m_left; ++i)
+            m_obj_p->set(i, false);
+    }
+}
+
+void
+sc_unsigned_subref::concat_set(uint64 src, int low_i)
+{
+    int  i;
+    int  l;
+
+    if (low_i < 64) {
+        src = src >> low_i;
+        l = sc_min(m_left, (63 - low_i) + m_right);
+        for (i = m_right; i <= l; ++i) {
+            m_obj_p->set(i, src & 1);
+            src = src >> 1;
+        }
+        for (; i <= m_left; i++)
+            m_obj_p->set(false);
+    } else {
+        for (i = m_right; i <= m_left; ++i)
+            m_obj_p->set(false);
+    }
+}
+
+// other methods
+void
+sc_unsigned_subref::scan(::std::istream &is)
+{
+    std::string s;
+    is >> s;
+    *this = s.c_str();
+}
diff --git a/src/systemc/dt/misc/SConscript b/src/systemc/dt/misc/SConscript
new file mode 100644
index 0000000..6f6d819
--- /dev/null
+++ b/src/systemc/dt/misc/SConscript
@@ -0,0 +1,32 @@
+# Copyright 2018 Google, Inc.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met: redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer;
+# redistributions in binary form must reproduce the above copyright
+# notice, this list of conditions and the following disclaimer in the
+# documentation and/or other materials provided with the distribution;
+# neither the name of the copyright holders nor the names of its
+# 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
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+# Authors: Gabe Black
+
+Import('*')
+
+if env['USE_SYSTEMC']:
+    Source('sc_concatref.cc')
+    Source('sc_value_base.cc')
diff --git a/src/systemc/dt/misc/sc_concatref.cc b/src/systemc/dt/misc/sc_concatref.cc
new file mode 100644
index 0000000..cb31efb
--- /dev/null
+++ b/src/systemc/dt/misc/sc_concatref.cc
@@ -0,0 +1,66 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+    sc_concatref.cpp -- Concatenation support.
+
+    Original Author: Andy Goodrich, Forte Design Systems, Inc.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+// $Log: sc_concatref.cpp,v $
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:54:01  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#include "systemc/ext/dt/misc/sc_concatref.hh"
+#include "systemc/ext/dt/sc_temporary.hh"
+
+// STORAGE POOLS USED BY sc_concatref:
+namespace sc_core
+{
+
+template class sc_vpool<sc_dt::sc_concatref>;
+template class sc_vpool<sc_dt::sc_concat_bool>;
+sc_byte_heap sc_temp_heap(0x300000);
+
+} // namespace sc_core
+
+namespace sc_dt
+{
+
+sc_core::sc_vpool<sc_concat_bool> sc_concat_bool::m_pool(9);
+sc_core::sc_vpool<sc_concatref> sc_concatref::m_pool(9);
+
+} // namespace sc_dt
diff --git a/src/systemc/dt/misc/sc_value_base.cc b/src/systemc/dt/misc/sc_value_base.cc
new file mode 100644
index 0000000..774f583
--- /dev/null
+++ b/src/systemc/dt/misc/sc_value_base.cc
@@ -0,0 +1,137 @@
+/*****************************************************************************
+
+  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+  more contributor license agreements.  See the NOTICE file distributed
+  with this work for additional information regarding copyright ownership.
+  Accellera licenses this file to you under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with the
+  License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied.  See the License for the specific language governing
+  permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  sc_value_base.cpp -- Base class for all SystemC data values.
+
+  Original Author: Andy Goodrich, Forte Design Systems
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
+  changes you are making here.
+
+      Name, Affiliation, Date:
+  Description of Modification:
+
+ *****************************************************************************/
+
+
+// $Log: sc_value_base.cpp,v $
+// Revision 1.2  2011/08/15 16:43:24  acg
+//  Torsten Maehne: changes to remove unused argument warnings.
+//
+// Revision 1.1.1.1  2006/12/15 20:20:05  acg
+// SystemC 2.3
+//
+// Revision 1.3  2006/01/13 18:54:01  acg
+// Andy Goodrich: added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#include <cctype>
+#include <cstdio>
+#include <cstdlib>
+
+#include "systemc/ext/dt/misc/sc_value_base.hh"
+#include "systemc/ext/utils/sc_report_handler.hh"
+
+namespace sc_dt
+{
+
+void
+sc_value_base::concat_clear_data(bool /* to_ones */)
+{
+    static const char error_message[] =
+        "concat_clear_data method not supported by this type";
+    SC_REPORT_ERROR("operation failed", error_message);
+}
+
+bool
+sc_value_base::concat_get_ctrl(sc_digit * /*dst_p*/, int /*low_i*/) const
+{
+    static const char error_message[] =
+        "concat_get_ctrl method not supported by this type";
+    SC_REPORT_ERROR("operation failed", error_message);
+    return false;
+}
+
+bool
+sc_value_base::concat_get_data(sc_digit * /*dst_p*/, int /*low_i*/) const
+{
+    static const char error_message[] =
+        "concat_get_data method not supported by this type";
+    SC_REPORT_ERROR("operation failed", error_message);
+    return false;
+}
+
+sc_dt::uint64
+sc_value_base::concat_get_uint64() const
+{
+    static const char error_message[] =
+        "concat_get_uint64 method not supported by this type";
+    SC_REPORT_ERROR("operation failed", error_message);
+    return 0;
+}
+
+int
+sc_value_base::concat_length(bool * /*xz_present_p*/) const
+{
+    static const char error_message[] =
+        "concat_length method not supported by this type";
+    SC_REPORT_ERROR("operation failed", error_message);
+    return 0;
+}
+
+void
+sc_value_base::concat_set(int64 /*src*/, int /*low_i*/)
+{
+    static const char error_message[] =
+        "concat_set(int64) method not supported by this type";
+    SC_REPORT_ERROR("operation failed", error_message);
+}
+
+void
+sc_value_base::concat_set(const sc_signed &/*src*/, int /*low_i*/)
+{
+    static const char error_message[] =
+        "concat_set(sc_signed) method not supported by this type";
+    SC_REPORT_ERROR("operation failed", error_message);
+}
+
+void
+sc_value_base::concat_set(const sc_unsigned &/*src*/, int /*low_i*/)
+{
+    static const char error_message[] =
+        "concat_set(sc_unsigned) method not supported by this type";
+    SC_REPORT_ERROR("operation failed", error_message);
+}
+
+void
+sc_value_base::concat_set(uint64 /*src*/, int /*low_i*/)
+{
+    static const char error_message[] =
+        "concat_set(uint64) method not supported by this type";
+    SC_REPORT_ERROR("operation failed", error_message);
+}
+
+} // namespace sc_dt