difficulty.cpp:_ZL6mul128mmPm:
   82|      4|static inline uint64_t mul128(uint64_t multiplier, uint64_t multiplicand, uint64_t* product_hi) {
   83|       |  // multiplier   = ab = a * 2^32 + b
   84|       |  // multiplicand = cd = c * 2^32 + d
   85|       |  // ab * cd = a * c * 2^64 + (a * d + b * c) * 2^32 + b * d
   86|      4|  uint64_t a = hi_dword(multiplier);
   87|      4|  uint64_t b = lo_dword(multiplier);
   88|      4|  uint64_t c = hi_dword(multiplicand);
   89|      4|  uint64_t d = lo_dword(multiplicand);
   90|       |
   91|      4|  uint64_t ac = a * c;
   92|      4|  uint64_t ad = a * d;
   93|      4|  uint64_t bc = b * c;
   94|      4|  uint64_t bd = b * d;
   95|       |
   96|      4|  uint64_t adbc = ad + bc;
   97|      4|  uint64_t adbc_carry = adbc < ad ? 1 : 0;
  ------------------
  |  Branch (97:25): [True: 0, False: 4]
  ------------------
   98|       |
   99|       |  // multiplier * multiplicand = product_hi * 2^64 + product_lo
  100|      4|  uint64_t product_lo = bd + (adbc << 32);
  101|      4|  uint64_t product_lo_carry = product_lo < bd ? 1 : 0;
  ------------------
  |  Branch (101:31): [True: 0, False: 4]
  ------------------
  102|      4|  *product_hi = ac + (adbc >> 32) + (adbc_carry << 32) + product_lo_carry;
  103|      4|  assert(ac <= *product_hi);
  104|       |
  105|      4|  return product_lo;
  106|      4|}
difficulty.cpp:_ZL8hi_dwordm:
   74|      8|static inline uint64_t hi_dword(uint64_t val) {
   75|      8|  return val >> 32;
   76|      8|}
difficulty.cpp:_ZL8lo_dwordm:
   78|      8|static inline uint64_t lo_dword(uint64_t val) {
   79|      8|  return val & 0xFFFFFFFF;
   80|      8|}
difficulty.cpp:_ZL7ident64m:
  173|      4|static inline uint64_t ident64(uint64_t x) { return x; }
chacha.c:rol32:
   64|  7.03M|static inline uint32_t rol32(uint32_t x, int r) {
   65|  7.03M|  return (x << (r & 31)) | (x >> (-r & 31));
   66|  7.03M|}
keccak.c:ident64:
  173|   629k|static inline uint64_t ident64(uint64_t x) { return x; }
keccak.c:memcpy_ident64:
  235|  28.4k|static inline void memcpy_ident64(void *dst, const void *src, size_t n) {
  236|  28.4k|  memcpy(dst, src, 8 * n);
  237|  28.4k|}

_ZN5tools8scrubbedIN6crypto9ec_scalarEED2Ev:
   57|   567k|    ~scrubbed() {
   58|   567k|      scrub();
   59|   567k|    }
_ZN5tools8scrubbedIN6crypto9ec_scalarEE5scrubEv:
   62|   567k|    void scrub() {
   63|   567k|      static_assert(std::is_pod<T>::value,
   64|   567k|                    "T cannot be auto-scrubbed. T must be POD.");
   65|   567k|      static_assert(std::is_trivially_destructible<T>::value,
   66|   567k|                    "T cannot be auto-scrubbed. T must be trivially destructable.");
   67|   567k|      memwipe(this, sizeof(T));
   68|   567k|    }
_ZN5tools6unwrapIN6crypto9ec_scalarEEERT_RNS_8scrubbedIS3_EE:
   72|      1|  T& unwrap(scrubbed<T>& src) { return src; }
_ZN5tools8scrubbedINSt3__15arrayIcLm32EEEE5scrubEv:
   62|  5.60k|    void scrub() {
   63|  5.60k|      static_assert(std::is_pod<T>::value,
   64|  5.60k|                    "T cannot be auto-scrubbed. T must be POD.");
   65|  5.60k|      static_assert(std::is_trivially_destructible<T>::value,
   66|  5.60k|                    "T cannot be auto-scrubbed. T must be trivially destructable.");
   67|  5.60k|      memwipe(this, sizeof(T));
   68|  5.60k|    }
_ZN5tools6unwrapINSt3__15arrayIhLm32EEEEERT_RNS_8scrubbedIS4_EE:
   72|  5.60k|  T& unwrap(scrubbed<T>& src) { return src; }
_ZN5tools8scrubbedINSt3__15arrayIcLm32EEEED2Ev:
   57|  5.60k|    ~scrubbed() {
   58|  5.60k|      scrub();
   59|  5.60k|    }
_ZN5tools8scrubbedINSt3__15arrayIcLm33EEEED2Ev:
   57|      3|    ~scrubbed() {
   58|      3|      scrub();
   59|      3|    }
_ZN5tools8scrubbedINSt3__15arrayIcLm33EEEE5scrubEv:
   62|      3|    void scrub() {
   63|      3|      static_assert(std::is_pod<T>::value,
   64|      3|                    "T cannot be auto-scrubbed. T must be POD.");
   65|      3|      static_assert(std::is_trivially_destructible<T>::value,
   66|      3|                    "T cannot be auto-scrubbed. T must be trivially destructable.");
   67|      3|      memwipe(this, sizeof(T));
   68|      3|    }
_ZN5tools8scrubbedINSt3__15arrayIhLm32EEEED2Ev:
   57|  5.60k|    ~scrubbed() {
   58|  5.60k|      scrub();
   59|  5.60k|    }
_ZN5tools8scrubbedINSt3__15arrayIhLm32EEEE5scrubEv:
   62|  5.60k|    void scrub() {
   63|  5.60k|      static_assert(std::is_pod<T>::value,
   64|  5.60k|                    "T cannot be auto-scrubbed. T must be POD.");
   65|  5.60k|      static_assert(std::is_trivially_destructible<T>::value,
   66|  5.60k|                    "T cannot be auto-scrubbed. T must be trivially destructable.");
   67|  5.60k|      memwipe(this, sizeof(T));
   68|  5.60k|    }
_ZN5tools8scrubbedINSt3__15arrayIcLm65EEEED2Ev:
   57|      1|    ~scrubbed() {
   58|      1|      scrub();
   59|      1|    }
_ZN5tools8scrubbedINSt3__15arrayIcLm65EEEE5scrubEv:
   62|      1|    void scrub() {
   63|      1|      static_assert(std::is_pod<T>::value,
   64|      1|                    "T cannot be auto-scrubbed. T must be POD.");
   65|      1|      static_assert(std::is_trivially_destructible<T>::value,
   66|      1|                    "T cannot be auto-scrubbed. T must be trivially destructable.");
   67|      1|      memwipe(this, sizeof(T));
   68|      1|    }

_ZN4epee7mlockedIN5tools8scrubbedIN6crypto9ec_scalarEEEEC2Ev:
   71|   325k|    mlocked(): T() { mlocker::lock(this, sizeof(T)); }
_ZN4epee6unwrapIN5tools8scrubbedIN6crypto9ec_scalarEEEEERT_RNS_7mlockedIS6_EE:
   81|   196k|  T& unwrap(mlocked<T>& src) { return src; }
_ZN4epee7mlockedIN5tools8scrubbedIN6crypto9ec_scalarEEEED2Ev:
   77|   567k|    ~mlocked() { try { mlocker::unlock(this, sizeof(T)); } catch (...) { /* do not propagate */ } }
_ZN4epee6unwrapIN5tools8scrubbedINSt3__15arrayIhLm32EEEEEEERT_RNS_7mlockedIS7_EE:
   81|  5.60k|  T& unwrap(mlocked<T>& src) { return src; }
_ZN4epee6unwrapIN5tools8scrubbedIN6crypto9ec_scalarEEEEERKT_RKNS_7mlockedIS6_EE:
   84|  17.3k|  const T& unwrap(mlocked<T> const& src) { return src; }
_ZN4epee7mlockedIN5tools8scrubbedIN6crypto9ec_scalarEEEEaSERKS6_:
   76|  99.5k|    mlocked<T> &operator=(const mlocked<T> &mt) { T::operator=(mt); return *this; }
_ZN4epee7mlockedIN5tools8scrubbedINSt3__15arrayIcLm32EEEEEEC2Ev:
   71|  5.60k|    mlocked(): T() { mlocker::lock(this, sizeof(T)); }
_ZN4epee7mlockedIN5tools8scrubbedINSt3__15arrayIcLm32EEEEEED2Ev:
   77|  5.60k|    ~mlocked() { try { mlocker::unlock(this, sizeof(T)); } catch (...) { /* do not propagate */ } }
_ZN4epee7mlockedIN5tools8scrubbedINSt3__15arrayIcLm33EEEEEEC2Ev:
   71|      3|    mlocked(): T() { mlocker::lock(this, sizeof(T)); }
_ZN4epee7mlockedIN5tools8scrubbedINSt3__15arrayIcLm33EEEEEED2Ev:
   77|      3|    ~mlocked() { try { mlocker::unlock(this, sizeof(T)); } catch (...) { /* do not propagate */ } }
_ZN4epee7mlockedIN5tools8scrubbedIN6crypto9ec_scalarEEEEC2ERKS6_:
   73|   140k|    mlocked(const mlocked<T> &mt): T(mt) { mlocker::lock(this, sizeof(T)); }
_ZN4epee7mlockedIN5tools8scrubbedINSt3__15arrayIhLm32EEEEEEC2Ev:
   71|  5.60k|    mlocked(): T() { mlocker::lock(this, sizeof(T)); }
_ZN4epee7mlockedIN5tools8scrubbedINSt3__15arrayIhLm32EEEEEED2Ev:
   77|  5.60k|    ~mlocked() { try { mlocker::unlock(this, sizeof(T)); } catch (...) { /* do not propagate */ } }
_ZN4epee7mlockedIN5tools8scrubbedINSt3__15arrayIhLm32EEEEEEaSERKS7_:
   76|      1|    mlocked<T> &operator=(const mlocked<T> &mt) { T::operator=(mt); return *this; }
_ZN4epee7mlockedIN5tools8scrubbedINSt3__15arrayIhLm32EEEEEEC2ERKS7_:
   73|      2|    mlocked(const mlocked<T> &mt): T(mt) { mlocker::lock(this, sizeof(T)); }
_ZN4epee7mlockedIN5tools8scrubbedIN6crypto9ec_scalarEEEEC2EOKS6_:
   75|   100k|    mlocked(const mlocked<T> &&mt): T(mt) { mlocker::lock(this, sizeof(T)); }
_ZN4epee7mlockedIN5tools8scrubbedINSt3__15arrayIcLm65EEEEEEC2Ev:
   71|      1|    mlocked(): T() { mlocker::lock(this, sizeof(T)); }
_ZN4epee7mlockedIN5tools8scrubbedINSt3__15arrayIcLm65EEEEEED2Ev:
   77|      1|    ~mlocked() { try { mlocker::unlock(this, sizeof(T)); } catch (...) { /* do not propagate */ } }

_ZN4epee9net_utils4http19http_client_factoryD2Ev:
   81|      1|    virtual ~http_client_factory() {}
_ZN4epee9net_utils4http20abstract_http_clientC2Ev:
   63|      2|    abstract_http_client() {}
_ZN4epee9net_utils4http20abstract_http_clientD2Ev:
   64|      2|    virtual ~abstract_http_client() {}

_ZN4epee9net_utils4http16http_client_authC2Ev:
  129|      3|      http_client_auth() : user() {}

_ZN4epee9net_utils4http27http_simple_client_templateINS0_19blocked_mode_clientEEC2Ev:
  102|      2|				: i_target_handler(), abstract_http_client()
  103|      2|				, m_net_client()
  104|      2|				, m_host_buff()
  105|      2|				, m_port()
  106|      2|				, m_auth()
  107|      2|				, m_header_cache()
  108|      2|				, m_response_info()
  109|      2|				, m_len_in_summary(0)
  110|      2|				, m_len_in_remain(0)
  111|      2|				, m_pcontent_encoding_handler(nullptr)
  112|       |				, m_state()
  113|       |				, m_chunked_state()
  114|      2|				, m_chunked_cache()
  115|      2|				, m_auto_connect(true)
  116|      2|				, m_lock()
  117|      2|			{}
_ZN4epee9net_utils4http27http_simple_client_templateINS0_19blocked_mode_clientEE13set_connectorINS0_14direct_connectEEEvT_:
  141|      2|			{
  142|      2|				CRITICAL_REGION_LOCAL(m_lock);
  ------------------
  |  |  153|      2|#define  CRITICAL_REGION_LOCAL(x) {} epee::critical_region_t<decltype(x)>   critical_region_var(x)
  ------------------
  143|      2|				m_net_client.set_connector(std::move(connector));
  144|      2|			}
_ZN4epee9net_utils4http27http_simple_client_templateINS0_19blocked_mode_clientEE10disconnectEv:
  153|      3|			{
  154|      3|				CRITICAL_REGION_LOCAL(m_lock);
  ------------------
  |  |  153|      3|#define  CRITICAL_REGION_LOCAL(x) {} epee::critical_region_t<decltype(x)>   critical_region_var(x)
  ------------------
  155|      3|				return m_net_client.disconnect();
  156|      3|			}
_ZN4epee9net_utils4http27http_simple_client_templateINS0_19blocked_mode_clientEE10set_serverENSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEESB_N5boost8optionalINS1_5loginEEENS0_13ssl_options_tE:
  125|      1|			{
  126|      1|				CRITICAL_REGION_LOCAL(m_lock);
  ------------------
  |  |  153|      1|#define  CRITICAL_REGION_LOCAL(x) {} epee::critical_region_t<decltype(x)>   critical_region_var(x)
  ------------------
  127|      1|				disconnect();
  128|      1|				m_host_buff = std::move(host);
  129|      1|				m_port = std::move(port);
  130|      1|				m_auth = user ? http_client_auth{std::move(*user)} : http_client_auth{};
  ------------------
  |  Branch (130:14): [True: 0, False: 1]
  ------------------
  131|      1|				m_net_client.set_ssl(std::move(ssl_options));
  132|      1|			}
_ZN4epee9net_utils4http27http_simple_client_templateINS0_19blocked_mode_clientEE12is_connectedEPb:
  159|      1|			{
  160|      1|				CRITICAL_REGION_LOCAL(m_lock);
  ------------------
  |  |  153|      1|#define  CRITICAL_REGION_LOCAL(x) {} epee::critical_region_t<decltype(x)>   critical_region_var(x)
  ------------------
  161|      1|				return m_net_client.is_connected(ssl);
  162|      1|			}

_ZN4epee9net_utils16i_target_handlerD2Ev:
   55|      2|      virtual ~i_target_handler(){}

_ZN4epee9net_utils19blocked_mode_clientC2Ev:
   97|      2|				m_io_service(),
   98|      2|				m_ctx(boost::asio::ssl::context::tlsv12),
   99|      2|				m_ssl_socket(new boost::asio::ssl::stream<boost::asio::ip::tcp::socket>(m_io_service, m_ctx)),
  100|      2|				m_connector(direct_connect{}),
  101|      2|				m_ssl_options(epee::net_utils::ssl_support_t::e_ssl_support_autodetect),
  102|      2|				m_connected(false),
  103|      2|				m_deadline(m_io_service, std::chrono::steady_clock::time_point::max()),
  104|      2|				m_shutdowned(false),
  105|      2|				m_bytes_sent(0),
  106|      2|				m_bytes_received(0)
  107|      2|		{
  108|      2|			check_deadline();
  109|      2|		}
_ZN4epee9net_utils19blocked_mode_clientD2Ev:
  129|      2|		{
  130|       |			//profile_tools::local_coast lc("~blocked_mode_client()", 3);
  131|      2|			try { shutdown(); }
  132|      2|			catch(...) { /* ignore */ }
  133|      2|		}
_ZN4epee9net_utils19blocked_mode_client7set_sslENS0_13ssl_options_tE:
  136|      1|		{
  137|      1|			if (ssl_options)
  ------------------
  |  Branch (137:8): [True: 0, False: 1]
  ------------------
  138|      0|				m_ctx = ssl_options.create_context();
  139|      1|			else
  140|      1|				m_ctx = boost::asio::ssl::context(boost::asio::ssl::context::tlsv12);
  141|      1|			m_ssl_options = std::move(ssl_options);
  142|      1|		}
_ZN4epee9net_utils19blocked_mode_client13set_connectorENSt3__18functionIFN5boost13unique_futureINS4_4asio19basic_stream_socketINS6_2ip3tcpENS6_15any_io_executorEEEEERKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEESK_RNS6_20basic_waitable_timerINS2_6chrono12steady_clockENS6_11wait_traitsISN_EESA_EEEEE:
  237|      2|		{
  238|      2|			m_connector = std::move(connector);
  239|      2|		}
_ZN4epee9net_utils19blocked_mode_client10disconnectEv:
  243|      3|		{
  244|      3|			try
  245|      3|			{	
  246|      3|				if(m_connected)
  ------------------
  |  Branch (246:8): [True: 0, False: 3]
  ------------------
  247|      0|				{
  248|      0|					m_connected = false;
  249|      0|					if(m_ssl_options)
  ------------------
  |  Branch (249:9): [True: 0, False: 0]
  ------------------
  250|      0|						shutdown_ssl();
  251|      0|					m_ssl_socket->next_layer().shutdown(boost::asio::ip::tcp::socket::shutdown_both);
  252|      0|				}
  253|      3|			}
  254|      3|			catch(const boost::system::system_error& /*er*/)
  255|      3|			{
  256|       |				//LOG_ERROR("Some problems at disconnect, message: " << er.what());
  257|      0|				return false;
  258|      0|			}
  259|      3|			catch(...)
  260|      3|			{
  261|       |				//LOG_ERROR("Some fatal problems.");
  262|      0|				return false;
  263|      0|			}
  264|      3|			return true;
  265|      3|		}
_ZN4epee9net_utils19blocked_mode_client12is_connectedEPb:
  323|      1|		{
  324|      1|			if (!m_connected || !m_ssl_socket->next_layer().is_open())
  ------------------
  |  Branch (324:8): [True: 1, False: 0]
  |  Branch (324:24): [True: 0, False: 0]
  ------------------
  325|      1|				return false;
  326|      0|			if (ssl)
  ------------------
  |  Branch (326:8): [True: 0, False: 0]
  ------------------
  327|      0|				*ssl = m_ssl_options.support != ssl_support_t::e_ssl_support_disabled;
  328|      0|			return true;
  329|      1|		}
_ZN4epee9net_utils19blocked_mode_client8shutdownEv:
  419|      2|		{
  420|      2|			m_deadline.cancel();
  421|      2|			boost::system::error_code ec;
  422|      2|			if(m_ssl_options)
  ------------------
  |  Branch (422:7): [True: 1, False: 1]
  ------------------
  423|      1|				shutdown_ssl();
  424|      2|			m_ssl_socket->next_layer().cancel(ec);
  425|      2|			if(ec)
  ------------------
  |  Branch (425:7): [True: 2, False: 0]
  ------------------
  426|      2|				MDEBUG("Problems at cancel: " << ec.message());
  ------------------
  |  |   78|      2|#define MDEBUG(x) MCDEBUG(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  ------------------
  |  |  |  |   56|      2|#define MCDEBUG(cat,x) MCLOG(el::Level::Debug,cat, el::Color::Default, x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      2|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   43|      2|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |   44|      2|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 2]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |   47|      2|  } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  427|      2|			m_ssl_socket->next_layer().shutdown(boost::asio::ip::tcp::socket::shutdown_both, ec);
  428|      2|			if(ec)
  ------------------
  |  Branch (428:7): [True: 2, False: 0]
  ------------------
  429|      2|				MDEBUG("Problems at shutdown: " << ec.message());
  ------------------
  |  |   78|      2|#define MDEBUG(x) MCDEBUG(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  ------------------
  |  |  |  |   56|      2|#define MCDEBUG(cat,x) MCLOG(el::Level::Debug,cat, el::Color::Default, x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      2|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   43|      2|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |   44|      2|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 2]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |   47|      2|  } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  430|      2|			m_ssl_socket->next_layer().close(ec);
  431|      2|			if(ec)
  ------------------
  |  Branch (431:7): [True: 0, False: 2]
  ------------------
  432|      2|				MDEBUG("Problems at close: " << ec.message());
  ------------------
  |  |   78|      2|#define MDEBUG(x) MCDEBUG(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  ------------------
  |  |  |  |   56|      2|#define MCDEBUG(cat,x) MCLOG(el::Level::Debug,cat, el::Color::Default, x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  433|      2|			m_shutdowned = true;
  434|      2|      m_connected = false;
  435|      2|			return true;
  436|      2|		}
_ZN4epee9net_utils19blocked_mode_client14check_deadlineEv:
  451|      3|		{
  452|       |			// Check whether the deadline has passed. We compare the deadline against
  453|       |			// the current time since a new asynchronous operation may have moved the
  454|       |			// deadline before this actor had a chance to run.
  455|      3|			if (m_deadline.expiry() <= std::chrono::steady_clock::now())
  ------------------
  |  Branch (455:8): [True: 0, False: 3]
  ------------------
  456|      0|			{
  457|       |				// The deadline has passed. The socket is closed so that any outstanding
  458|       |				// asynchronous operations are cancelled. This allows the blocked
  459|       |				// connect(), read_line() or write_line() functions to return.
  460|      0|				LOG_PRINT_L3("Timed out socket");
  ------------------
  |  |  104|      0|#define LOG_PRINT_L3(x) MTRACE(x)
  |  |  ------------------
  |  |  |  |   79|      0|#define MTRACE(x) MCTRACE(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|      0|#define MCTRACE(cat,x) MCLOG(el::Level::Trace,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  461|      0|        m_connected = false;
  462|      0|				m_ssl_socket->next_layer().close();
  463|       |
  464|       |				// There is no longer an active deadline. The expiry is set to positive
  465|       |				// infinity so that the actor takes no action until a new deadline is set.
  466|      0|				m_deadline.expires_at(std::chrono::steady_clock::time_point::max());
  467|      0|			}
  468|       |
  469|       |			// Put the actor back to sleep.
  470|      3|			m_deadline.async_wait(boost::bind(&blocked_mode_client::check_deadline, this));
  471|      3|		}
_ZN4epee9net_utils19blocked_mode_client12shutdown_sslEv:
  473|      1|		void shutdown_ssl() {
  474|       |			// ssl socket shutdown blocks if server doesn't respond. We close after 2 secs
  475|      1|			boost::system::error_code ec = boost::asio::error::would_block;
  476|      1|			m_deadline.expires_after(std::chrono::milliseconds(2000));
  477|      1|			m_ssl_socket->async_shutdown(boost::lambda::var(ec) = boost::lambda::_1);
  478|      3|			while (ec == boost::asio::error::would_block)
  ------------------
  |  Branch (478:11): [True: 2, False: 1]
  ------------------
  479|      2|			{
  480|      2|				m_io_service.restart();
  481|      2|				m_io_service.run_one();
  482|      2|			}
  483|       |			// Ignore "short read" error
  484|      1|			if (ec.category() == boost::asio::error::get_ssl_category() &&
  ------------------
  |  Branch (484:8): [True: 1, False: 0]
  ------------------
  485|      1|			    ec.value() !=
  ------------------
  |  Branch (485:8): [True: 1, False: 0]
  ------------------
  486|      1|#if BOOST_VERSION >= 106200
  487|      1|			    boost::asio::ssl::error::stream_truncated
  488|       |#else // older Boost supports only OpenSSL 1.0, so 1.0-only macros are appropriate
  489|       |			    ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SHORT_READ)
  490|       |#endif
  491|      1|			    )
  492|      1|				MDEBUG("Problems at ssl shutdown: " << ec.message());
  ------------------
  |  |   78|      1|#define MDEBUG(x) MCDEBUG(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  ------------------
  |  |  |  |   56|      1|#define MCDEBUG(cat,x) MCLOG(el::Level::Debug,cat, el::Color::Default, x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      1|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   43|      1|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |   44|      1|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 1]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |   47|      1|  } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  493|      1|		}

_ZN4epee9net_utils13ssl_options_tC2ENS0_13ssl_support_tE:
   89|      3|      : fingerprints_(),
   90|      3|        ca_path(),
   91|      3|        auth(),
   92|      3|        support(support),
   93|      3|        verification(support == ssl_support_t::e_ssl_support_disabled ? ssl_verification_t::none : ssl_verification_t::system_ca)
  ------------------
  |  Branch (93:22): [True: 1, False: 2]
  ------------------
   94|      3|    {}
_ZNK4epee9net_utils13ssl_options_tcvbEv:
  106|      3|    explicit operator bool() const noexcept { return support != ssl_support_t::e_ssl_support_disabled; }
_ZN4epee9net_utils13ssl_options_taSEOS1_:
  103|      1|    ssl_options_t& operator=(ssl_options_t&&) = default;
_ZN4epee9net_utils13ssl_options_tC2EOS1_:
  100|      4|    ssl_options_t(ssl_options_t&&) = default;

_ZN4epee30global_regexp_critical_sectionC2Ev:
   42|     14|    global_regexp_critical_section(){}
_ZNK4epee30global_regexp_critical_section8get_lockEv:
   43|      6|    critical_section& get_lock()const {return regexp_lock;}

_ZN4epee16as_mut_byte_spanIN6crypto9ec_scalarEEENS_4spanIhEERT_:
  170|      1|  {
  171|      1|    static_assert(!std::is_empty<T>(), "empty types will not work -> sizeof == 1");
  172|      1|    static_assert(std::is_standard_layout_v<T>, "type must have standard layout");
  173|      1|    static_assert(std::has_unique_object_representations_v<T>, "type must be trivially copyable with no padding");
  174|      1|    return {reinterpret_cast<std::uint8_t*>(std::addressof(src)), sizeof(T)};
  175|      1|  }
_ZN4epee4spanIhEC2IhvEEPT_m:
   82|     55|      : ptr(src_ptr), len(count) {}
_ZN4epee4spanIKhEC2IS1_vEEPT_m:
   82|  1.02M|      : ptr(src_ptr), len(count) {}
_ZNK4epee4spanIKhE5beginEv:
  101|  11.1k|    constexpr iterator begin() const noexcept { return ptr; }
_ZNK4epee4spanIKhE6cbeginEv:
  102|  4.04M|    constexpr const_iterator cbegin() const noexcept { return ptr; }
_ZNK4epee4spanIKhE4cendEv:
  105|  3.03M|    constexpr const_iterator cend() const noexcept { return cbegin() + size(); }
_ZNK4epee4spanIKhE4sizeEv:
  109|  3.43M|    constexpr std::size_t size() const noexcept { return len; }
_ZN4epee4spanIKhE13remove_prefixEm:
   94|  4.66M|    {
   95|  4.66M|        amount = std::min(len, amount);
   96|  4.66M|        ptr += amount;
   97|  4.66M|        len -= amount;
   98|  4.66M|        return amount;
   99|  4.66M|    }
_ZNK4epee4spanIKhE4dataEv:
  108|  4.66M|    constexpr pointer data() const noexcept { return ptr; }
_ZNK4epee4spanIKhE5emptyEv:
  107|  40.7k|    constexpr bool empty() const noexcept { return size() == 0; }
_ZN4epee7strspanIhNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS_4spanIKT_EERKT0_:
  180|    229|  {
  181|    229|    static_assert(std::is_same<typename U::value_type, char>(), "unexpected source type");
  182|    229|    static_assert(std::is_same<T, char>() || std::is_same<T, unsigned char>() || std::is_same<T, int8_t>() || std::is_same<T, uint8_t>(), "Unexpected destination type");
  183|    229|    return {reinterpret_cast<const T*>(s.data()), s.size()};
  184|    229|  }
_ZN4epee16as_mut_byte_spanIN6crypto4hashEEENS_4spanIhEERT_:
  170|     54|  {
  171|     54|    static_assert(!std::is_empty<T>(), "empty types will not work -> sizeof == 1");
  172|     54|    static_assert(std::is_standard_layout_v<T>, "type must have standard layout");
  173|     54|    static_assert(std::has_unique_object_representations_v<T>, "type must be trivially copyable with no padding");
  174|     54|    return {reinterpret_cast<std::uint8_t*>(std::addressof(src)), sizeof(T)};
  175|     54|  }
_ZNK4epee4spanIhE4dataEv:
  108|     55|    constexpr pointer data() const noexcept { return ptr; }
_ZNK4epee4spanIhE4sizeEv:
  109|     55|    constexpr std::size_t size() const noexcept { return len; }
_ZN4epee7to_spanINSt3__16vectorIhNS1_9allocatorIhEEEEEENS_4spanIKNT_10value_typeEEERKS7_:
  123|  1.21k|  {
  124|       |    // compiler provides diagnostic if size() is not size_t.
  125|  1.21k|    return {src.data(), src.size()};
  126|  1.21k|  }
_ZNK4epee4spanIKN3rct3keyEE4sizeEv:
  109|    134|    constexpr std::size_t size() const noexcept { return len; }
_ZN4epee4spanIKN3rct3keyEEC2IS3_vEEPT_m:
   82|      4|      : ptr(src_ptr), len(count) {}
_ZN4epee7strspanIhN5boost16basic_string_refIcNSt3__111char_traitsIcEEEEEENS_4spanIKT_EERKT0_:
  180|      1|  {
  181|      1|    static_assert(std::is_same<typename U::value_type, char>(), "unexpected source type");
  182|      1|    static_assert(std::is_same<T, char>() || std::is_same<T, unsigned char>() || std::is_same<T, int8_t>() || std::is_same<T, uint8_t>(), "Unexpected destination type");
  183|      1|    return {reinterpret_cast<const T*>(s.data()), s.size()};
  184|      1|  }
_ZNK4epee4spanIKN3rct3keyEEixEm:
  113|    256|    const T &operator[](size_t idx) const noexcept { return ptr[idx]; }

_ZN4epee12string_tools10hex_to_podIN5tools8scrubbedIN6crypto9ec_scalarEEEEEbN5boost16basic_string_refIcNSt3__111char_traitsIcEEEERNS_7mlockedIT_EE:
  112|      1|  {
  113|      1|    return hex_to_pod(hex_str, unwrap(s));
  114|      1|  }
_ZN4epee12string_tools10hex_to_podIN6crypto9ec_scalarEEEbN5boost16basic_string_refIcNSt3__111char_traitsIcEEEERN5tools8scrubbedIT_EE:
  106|      1|  {
  107|      1|    return hex_to_pod(hex_str, unwrap(s));
  108|      1|  }
_ZN4epee12string_tools10hex_to_podIN6crypto9ec_scalarEEEbN5boost16basic_string_refIcNSt3__111char_traitsIcEEEERT_:
   98|      1|  {
   99|      1|    static_assert(std::is_standard_layout<t_pod_type>(), "expected standard layout type");
  100|      1|    static_assert(std::has_unique_object_representations_v<t_pod_type>, "type may have padding");
  101|      1|    return from_hex::to_buffer(as_mut_byte_span(s), hex_str);
  102|      1|  }
_ZN4epee12string_tools23parse_hexstr_to_binbuffEN5boost16basic_string_refIcNSt3__111char_traitsIcEEEERNS3_12basic_stringIcS5_NS3_9allocatorIcEEEE:
   58|      1|  {
   59|      1|    return from_hex::to_string(res, s);
   60|      1|  }
_ZN4epee12string_tools10hex_to_podIN6crypto4hashEEEbN5boost16basic_string_refIcNSt3__111char_traitsIcEEEERT_:
   98|     54|  {
   99|     54|    static_assert(std::is_standard_layout<t_pod_type>(), "expected standard layout type");
  100|     54|    static_assert(std::has_unique_object_representations_v<t_pod_type>, "type may have padding");
  101|     54|    return from_hex::to_buffer(as_mut_byte_span(s), hex_str);
  102|     54|  }

_ZN4epee16critical_sectionC2Ev:
   92|     16|    {
   93|     16|    }
_ZN4epee16critical_sectionD2Ev:
   96|      2|    {
   97|      2|    }
_ZN4epee16critical_section4lockEv:
  100|     10|    {
  101|     10|      m_section.lock();
  102|       |      //EnterCriticalSection( &m_section );
  103|     10|    }
_ZN4epee16critical_section6unlockEv:
  106|     10|    {
  107|     10|      m_section.unlock();
  108|     10|    }
_ZN4epee17critical_region_tIN5boost5mutexEE6unlockEv:
  143|      1|    {
  144|      1|      if (!m_unlocked)
  ------------------
  |  Branch (144:11): [True: 1, False: 0]
  ------------------
  145|      1|      {
  146|      1|        m_locker.unlock();
  147|      1|        m_unlocked = true;
  148|      1|      }
  149|      1|    }
_ZN4epee17critical_region_tIN5boost5mutexEEC2ERS2_:
  132|      1|    critical_region_t(t_lock& cs): m_locker(cs), m_unlocked(false)
  133|      1|    {
  134|      1|      m_locker.lock();
  135|      1|    }
_ZN4epee17critical_region_tIN5boost5mutexEED2Ev:
  138|      1|    {
  139|      1|      unlock();
  140|      1|    }
_ZN4epee17critical_region_tINS_16critical_sectionEEC2ERS1_:
  132|      7|    critical_region_t(t_lock& cs): m_locker(cs), m_unlocked(false)
  133|      7|    {
  134|      7|      m_locker.lock();
  135|      7|    }
_ZN4epee17critical_region_tINS_16critical_sectionEED2Ev:
  138|      7|    {
  139|      7|      unlock();
  140|      7|    }
_ZN4epee17critical_region_tINS_16critical_sectionEE6unlockEv:
  143|      7|    {
  144|      7|      if (!m_unlocked)
  ------------------
  |  Branch (144:11): [True: 7, False: 0]
  ------------------
  145|      7|      {
  146|      7|        m_locker.unlock();
  147|      7|        m_unlocked = true;
  148|      7|      }
  149|      7|    }
_ZN4epee17critical_region_tIRN5boost5mutexEEC2ES3_:
  132|  2.31M|    critical_region_t(t_lock& cs): m_locker(cs), m_unlocked(false)
  133|  2.31M|    {
  134|  2.31M|      m_locker.lock();
  135|  2.31M|    }
_ZN4epee17critical_region_tIRN5boost5mutexEED2Ev:
  138|  2.31M|    {
  139|  2.31M|      unlock();
  140|  2.31M|    }
_ZN4epee17critical_region_tIRN5boost5mutexEE6unlockEv:
  143|  2.31M|    {
  144|  2.31M|      if (!m_unlocked)
  ------------------
  |  Branch (144:11): [True: 2.31M, False: 0]
  ------------------
  145|  2.31M|      {
  146|  2.31M|        m_locker.unlock();
  147|  2.31M|        m_unlocked = true;
  148|  2.31M|      }
  149|  2.31M|    }

_ZN4epee10misc_utils12get_ns_countEv:
   76|  5.79M|	{
   77|  5.79M|		typedef std::chrono::duration<uint64_t, std::nano> ns_duration;
   78|  5.79M|		const ns_duration ns_since_epoch = std::chrono::steady_clock::now().time_since_epoch();
   79|  5.79M|		return ns_since_epoch.count();
   80|  5.79M|	}

_ZN4epee15wipeable_stringC2Ev:
   45|      1|    wipeable_string() {}
_ZNK4epee15wipeable_string4dataEv:
   61|      1|    const char *data() const noexcept { return buffer.data(); }
_ZN4epee15wipeable_string4dataEv:
   62|      6|    char *data() noexcept { return buffer.data(); }
_ZNK4epee15wipeable_string4sizeEv:
   63|      8|    size_t size() const noexcept { return buffer.size(); }

_ZN4epee9net_utils4http20abstract_http_client10set_serverERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEN5boost8optionalINS1_5loginEEENS0_13ssl_options_tE:
  124|      1|  {
  125|      1|    http::url_content parsed{};
  126|      1|    const bool r = parse_url(address, parsed);
  127|      1|    CHECK_AND_ASSERT_MES(r, false, "failed to parse url: " << address);
  ------------------
  |  |  183|      1|#define CHECK_AND_ASSERT_MES(expr, fail_ret_val, message)   do{if(!(expr)) {LOG_ERROR(message); return fail_ret_val;};}while(0)
  |  |  ------------------
  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (183:67): [True: 0, False: 1]
  |  |  |  Branch (183:126): [Folded - Ignored]
  |  |  ------------------
  ------------------
  128|      1|    set_server(std::move(parsed.host), std::to_string(parsed.port), std::move(user), std::move(ssl_options));
  129|      1|    return true;
  130|      1|  }

_ZN4epee13file_io_utils19save_string_to_fileERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_:
   72|  5.59k|	{
   73|       |#ifdef _WIN32
   74|       |                std::wstring wide_path;
   75|       |                try { wide_path = string_tools::utf8_to_utf16(path_to_file); } catch (...) { return false; }
   76|       |                HANDLE file_handle = CreateFileW(wide_path.c_str(), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
   77|       |                if (file_handle == INVALID_HANDLE_VALUE)
   78|       |                    return false;
   79|       |                DWORD bytes_written;
   80|       |                DWORD bytes_to_write = (DWORD)str.size();
   81|       |                BOOL result = WriteFile(file_handle, str.data(), bytes_to_write, &bytes_written, NULL);
   82|       |                CloseHandle(file_handle);
   83|       |                if (bytes_written != bytes_to_write)
   84|       |                    result = FALSE;
   85|       |                return result;
   86|       |#else
   87|  5.59k|		try
   88|  5.59k|		{
   89|  5.59k|			std::ofstream fstream;
   90|  5.59k|			fstream.exceptions(std::ifstream::failbit | std::ifstream::badbit);
   91|  5.59k|			fstream.open(path_to_file, std::ios_base::binary | std::ios_base::out | std::ios_base::trunc);
   92|  5.59k|			fstream << str;
   93|  5.59k|			fstream.close();
   94|  5.59k|			return true;
   95|  5.59k|		}
   96|       |
   97|  5.59k|		catch(...)
   98|  5.59k|		{
   99|      0|			return false;
  100|      0|		}
  101|  5.59k|#endif
  102|  5.59k|	}

_ZN4epee8from_hex9to_stringERNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN5boost16basic_string_refIcS4_EE:
   99|      1|  {
  100|      1|    out.resize(src.size() / 2);
  101|      1|    return to_buffer_unchecked(reinterpret_cast<std::uint8_t*>(&out[0]), src);
  102|      1|  }
_ZN4epee8from_hex9to_bufferENS_4spanIhEEN5boost16basic_string_refIcNSt3__111char_traitsIcEEEE:
  105|     55|  {
  106|     55|    if (src.size() / 2 != out.size())
  ------------------
  |  Branch (106:9): [True: 0, False: 55]
  ------------------
  107|      0|      return false;
  108|     55|    return to_buffer_unchecked(out.data(), src);
  109|     55|  }
_ZN4epee8from_hex19to_buffer_uncheckedEPhN5boost16basic_string_refIcNSt3__111char_traitsIcEEEE:
  112|     56|  {
  113|     56|      if (s.size() % 2 != 0)
  ------------------
  |  Branch (113:11): [True: 0, False: 56]
  ------------------
  114|      0|        return false;
  115|       |
  116|     56|      const unsigned char *src = (const unsigned char *)s.data();
  117|  1.89k|      for(size_t i = 0; i < s.size(); i += 2)
  ------------------
  |  Branch (117:25): [True: 1.84k, False: 56]
  ------------------
  118|  1.84k|      {
  119|  1.84k|        int tmp = *src++;
  120|  1.84k|        tmp = epee::misc_utils::parse::isx[tmp];
  121|  1.84k|        if (tmp == 0xff) return false;
  ------------------
  |  Branch (121:13): [True: 0, False: 1.84k]
  ------------------
  122|  1.84k|        int t2 = *src++;
  123|  1.84k|        t2 = epee::misc_utils::parse::isx[t2];
  124|  1.84k|        if (t2 == 0xff) return false;
  ------------------
  |  Branch (124:13): [True: 0, False: 1.84k]
  ------------------
  125|  1.84k|        *dst++ = (tmp << 4) | t2;
  126|  1.84k|      }
  127|       |
  128|     56|      return true;
  129|     56|  }

memwipe:
   69|   593k|{
   70|   593k|  if (n > 0)
  ------------------
  |  Branch (70:7): [True: 593k, False: 0]
  ------------------
   71|   593k|    explicit_bzero(ptr, n);
   72|   593k|  SCARECROW
  ------------------
  |  |   46|   593k|    __asm__ __volatile__("" : : "r"(ptr) : "memory");
  ------------------
   73|   593k|  return ptr;
   74|   593k|}

_ZN4epee7mlocker5mutexEv:
   98|  2.31M|  {
   99|  2.31M|    static boost::mutex *vmutex = new boost::mutex();
  100|  2.31M|    return *vmutex;
  101|  2.31M|  }
_ZN4epee7mlocker3mapEv:
  103|  1.75M|  {
  104|  1.75M|    static std::map<size_t, unsigned int> *vmap = new std::map<size_t, unsigned int>();
  105|  1.75M|    return *vmap;
  106|  1.75M|  }
_ZN4epee7mlocker13get_page_sizeEv:
  109|  1.15M|  {
  110|  1.15M|    CRITICAL_REGION_LOCAL(mutex());
  ------------------
  |  |  153|  1.15M|#define  CRITICAL_REGION_LOCAL(x) {} epee::critical_region_t<decltype(x)>   critical_region_var(x)
  ------------------
  111|  1.15M|    if (page_size == 0)
  ------------------
  |  Branch (111:9): [True: 2, False: 1.15M]
  ------------------
  112|      2|      page_size = query_page_size();
  113|  1.15M|    return page_size;
  114|  1.15M|  }
_ZN4epee7mlocker4lockEPvm:
  128|   578k|  {
  129|   578k|    TRY_ENTRY();
  ------------------
  |  |  153|   578k|#define TRY_ENTRY()   try {
  ------------------
  130|       |
  131|   578k|    size_t page_size = get_page_size();
  132|   578k|    if (page_size == 0)
  ------------------
  |  Branch (132:9): [True: 0, False: 578k]
  ------------------
  133|      0|      return;
  134|       |
  135|   578k|    CRITICAL_REGION_LOCAL(mutex());
  ------------------
  |  |  153|   578k|#define  CRITICAL_REGION_LOCAL(x) {} epee::critical_region_t<decltype(x)>   critical_region_var(x)
  ------------------
  136|   578k|    const size_t first = ((uintptr_t)ptr) / page_size;
  137|   578k|    const size_t last = (((uintptr_t)ptr) + len - 1) / page_size;
  138|  1.15M|    for (size_t page = first; page <= last; ++page)
  ------------------
  |  Branch (138:31): [True: 579k, False: 578k]
  ------------------
  139|   579k|      lock_page(page);
  140|   578k|    ++num_locked_objects;
  141|       |
  142|   578k|    CATCH_ENTRY_L1("mlocker::lock", void());
  ------------------
  |  |  168|   578k|#define CATCH_ENTRY_L1(lacation, return_val) CATCH_ENTRY(lacation, return_val)
  |  |  ------------------
  |  |  |  |  154|   578k|#define CATCH_ENTRY(location, return_val) } \
  |  |  |  |  155|   578k|  catch(const std::exception& ex) \
  |  |  |  |  156|      0|{ \
  |  |  |  |  157|      0|  (void)(ex); \
  |  |  |  |  158|      0|  LOG_ERROR("Exception at [" << location << "], what=" << ex.what()); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  159|      0|  return return_val; \
  |  |  |  |  160|      0|}\
  |  |  |  |  161|   578k|  catch(...)\
  |  |  |  |  162|      0|{\
  |  |  |  |  163|      0|  LOG_ERROR("Exception at [" << location << "], generic exception \"...\"");\
  |  |  |  |  ------------------
  |  |  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  164|      0|  return return_val; \
  |  |  |  |  165|      0|}
  |  |  ------------------
  ------------------
  143|   578k|  }
_ZN4epee7mlocker6unlockEPvm:
  146|   578k|  {
  147|   578k|    TRY_ENTRY();
  ------------------
  |  |  153|   578k|#define TRY_ENTRY()   try {
  ------------------
  148|       |
  149|   578k|    size_t page_size = get_page_size();
  150|   578k|    if (page_size == 0)
  ------------------
  |  Branch (150:9): [True: 0, False: 578k]
  ------------------
  151|      0|      return;
  152|   578k|    CRITICAL_REGION_LOCAL(mutex());
  ------------------
  |  |  153|   578k|#define  CRITICAL_REGION_LOCAL(x) {} epee::critical_region_t<decltype(x)>   critical_region_var(x)
  ------------------
  153|   578k|    const size_t first = ((uintptr_t)ptr) / page_size;
  154|   578k|    const size_t last = (((uintptr_t)ptr) + len - 1) / page_size;
  155|  1.15M|    for (size_t page = first; page <= last; ++page)
  ------------------
  |  Branch (155:31): [True: 579k, False: 578k]
  ------------------
  156|   579k|      unlock_page(page);
  157|   578k|    --num_locked_objects;
  158|       |
  159|   578k|    CATCH_ENTRY_L1("mlocker::lock", void());
  ------------------
  |  |  168|   578k|#define CATCH_ENTRY_L1(lacation, return_val) CATCH_ENTRY(lacation, return_val)
  |  |  ------------------
  |  |  |  |  154|   578k|#define CATCH_ENTRY(location, return_val) } \
  |  |  |  |  155|   578k|  catch(const std::exception& ex) \
  |  |  |  |  156|      0|{ \
  |  |  |  |  157|      0|  (void)(ex); \
  |  |  |  |  158|      0|  LOG_ERROR("Exception at [" << location << "], what=" << ex.what()); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  159|      0|  return return_val; \
  |  |  |  |  160|      0|}\
  |  |  |  |  161|   578k|  catch(...)\
  |  |  |  |  162|      0|{\
  |  |  |  |  163|      0|  LOG_ERROR("Exception at [" << location << "], generic exception \"...\"");\
  |  |  |  |  ------------------
  |  |  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  164|      0|  return return_val; \
  |  |  |  |  165|      0|}
  |  |  ------------------
  ------------------
  160|   578k|  }
_ZN4epee7mlocker9lock_pageEm:
  175|   579k|  {
  176|   579k|    std::pair<std::map<size_t, unsigned int>::iterator, bool> p = map().insert(std::make_pair(page, 1));
  177|   579k|    if (p.second)
  ------------------
  |  Branch (177:9): [True: 16.8k, False: 562k]
  ------------------
  178|  16.8k|    {
  179|  16.8k|      do_lock((void*)(page * page_size), page_size);
  180|  16.8k|    }
  181|   562k|    else
  182|   562k|    {
  183|   562k|      ++p.first->second;
  184|   562k|    }
  185|   579k|  }
_ZN4epee7mlocker11unlock_pageEm:
  188|   579k|  {
  189|   579k|    std::map<size_t, unsigned int>::iterator i = map().find(page);
  190|   579k|    if (i == map().end())
  ------------------
  |  Branch (190:9): [True: 0, False: 579k]
  ------------------
  191|      0|    {
  192|      0|      MERROR("Attempt to unlock unlocked page at " << (void*)(page * page_size));
  ------------------
  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  ------------------
  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  193|      0|    }
  194|   579k|    else
  195|   579k|    {
  196|   579k|      if (!--i->second)
  ------------------
  |  Branch (196:11): [True: 16.8k, False: 562k]
  ------------------
  197|  16.8k|      {
  198|  16.8k|        map().erase(i);
  199|  16.8k|        do_unlock((void*)(page * page_size), page_size);
  200|  16.8k|      }
  201|   579k|    }
  202|   579k|  }
mlocker.cpp:_ZL15query_page_sizev:
   52|      2|{
   53|      2|#if defined HAVE_MLOCK
   54|      2|  long ret = sysconf(_SC_PAGESIZE);
   55|      2|  if (ret <= 0)
  ------------------
  |  Branch (55:7): [True: 0, False: 2]
  ------------------
   56|      0|  {
   57|      0|    MERROR("Failed to determine page size");
  ------------------
  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  ------------------
  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   58|      0|    return 0;
   59|      0|  }
   60|      2|  return ret;
   61|       |#else
   62|       |#warning Missing query_page_size implementation
   63|       |#endif
   64|      0|  return 0;
   65|      2|}
mlocker.cpp:_ZL7do_lockPvm:
   68|  16.8k|{
   69|  16.8k|#if defined HAVE_MLOCK
   70|  16.8k|  int ret = mlock(ptr, len);
   71|  16.8k|  if (ret < 0 && !previously_failed.exchange(true))
  ------------------
  |  Branch (71:7): [True: 0, False: 16.8k]
  |  Branch (71:18): [True: 0, False: 0]
  ------------------
   72|  16.8k|    MERROR("Error locking page at " << ptr << ": " << strerror(errno) << ", subsequent mlock errors will be silenced");
  ------------------
  |  |   75|  16.8k|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  ------------------
  |  |  |  |   53|  16.8k|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   73|       |#else
   74|       |#warning Missing do_lock implementation
   75|       |#endif
   76|  16.8k|}
mlocker.cpp:_ZL9do_unlockPvm:
   79|  16.8k|{
   80|  16.8k|#if defined HAVE_MLOCK
   81|  16.8k|  int ret = munlock(ptr, len);
   82|       |  // check whether we previously failed, but don't set it, this is just
   83|       |  // to pacify the errors of mlock()ing failed, in which case unlocking
   84|       |  // is also not going to work of course
   85|  16.8k|  if (ret < 0 && !previously_failed.load())
  ------------------
  |  Branch (85:7): [True: 0, False: 16.8k]
  |  Branch (85:18): [True: 0, False: 0]
  ------------------
   86|  16.8k|    MERROR("Error unlocking page at " << ptr << ": " << strerror(errno));
  ------------------
  |  |   75|  16.8k|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  ------------------
  |  |  |  |   53|  16.8k|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   87|       |#else
   88|       |#warning Missing implementation of page size detection
   89|       |#endif
   90|  16.8k|}

_ZN4epee9net_utils9parse_uriENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERNS0_4http11uri_contentE:
   97|      1|  {
   98|       |
   99|       |    ///iframe_test.html?api_url=http://api.vk.com/api.php&api_id=3289090&api_settings=1&viewer_id=562964060&viewer_type=0&sid=0aad8d1c5713130f9ca0076f2b7b47e532877424961367d81e7fa92455f069be7e21bc3193cbd0be11895&secret=368ebbc0ef&access_token=668bc03f43981d883f73876ffff4aa8564254b359cc745dfa1b3cde7bdab2e94105d8f6d8250717569c0a7&user_id=0&group_id=0&is_app_user=1&auth_key=d2f7a895ca5ff3fdb2a2a8ae23fe679a&language=0&parent_language=0&ad_info=ElsdCQBaQlxiAQRdFUVUXiN2AVBzBx5pU1BXIgZUJlIEAWcgAUoLQg==&referrer=unknown&lc_name=9834b6a3&hash=
  100|      1|    content.m_query_params.clear();
  101|      1|    STATIC_REGEXP_EXPR_1(rexp_match_uri, "^([^?#]*)(\\?([^#]*))?(#(.*))?", boost::regex::icase | boost::regex::normal);
  ------------------
  |  |   49|      1|	static std::atomic<bool> regexp_initialized_1(false);\
  |  |   50|      1|	volatile uint32_t local_is_initialized_1 = regexp_initialized_1;\
  |  |   51|      1|	if(!local_is_initialized_1)\
  |  |  ------------------
  |  |  |  Branch (51:5): [True: 1, False: 0]
  |  |  ------------------
  |  |   52|      1|	gregexplock.get_lock().lock();\
  |  |   53|      1|	static const boost::regex	var_name(xpr_text , reg_exp_flags);\
  |  |   54|      1|	if(!local_is_initialized_1)\
  |  |  ------------------
  |  |  |  Branch (54:5): [True: 1, False: 0]
  |  |  ------------------
  |  |   55|      1|{\
  |  |   56|      1|	regexp_initialized_1 = true;\
  |  |   57|      1|	gregexplock.get_lock().unlock();\
  |  |   58|      1|}
  ------------------
  102|       |
  103|      1|    boost::smatch result;	
  104|      1|    if(!(boost::regex_search(uri, result, rexp_match_uri, boost::match_default) && result[0].matched))
  ------------------
  |  Branch (104:10): [True: 1, False: 0]
  |  Branch (104:84): [True: 1, False: 0]
  ------------------
  105|      0|    {
  106|      0|      LOG_PRINT_L1("[PARSE URI] regex not matched for uri: " << uri);
  ------------------
  |  |  102|      0|#define LOG_PRINT_L1(x) MINFO(x)
  |  |  ------------------
  |  |  |  |   77|      0|#define MINFO(x) MCINFO(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|      0|#define MCINFO(cat,x) MCLOG(el::Level::Info,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  107|      0|      content.m_path = uri;
  108|      0|      return true;
  109|      0|    }
  110|      1|    if(result[1].matched)
  ------------------
  |  Branch (110:8): [True: 1, False: 0]
  ------------------
  111|      1|    {
  112|      1|      content.m_path = result[1];
  113|      1|    }
  114|      1|    if(result[3].matched)
  ------------------
  |  Branch (114:8): [True: 0, False: 1]
  ------------------
  115|      0|    {
  116|      0|      content.m_query = result[3];
  117|      0|    }
  118|      1|    if(result[5].matched)
  ------------------
  |  Branch (118:8): [True: 0, False: 1]
  ------------------
  119|      0|    {
  120|      0|      content.m_fragment = result[5];
  121|      0|    }
  122|      1|    if(content.m_query.size())
  ------------------
  |  Branch (122:8): [True: 0, False: 1]
  ------------------
  123|      0|    {
  124|      0|      parse_uri_query(content.m_query, content.m_query_params);
  125|      0|    }
  126|      1|    return true;
  127|      1|  }
_ZN4epee9net_utils14parse_url_ipv6ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERNS0_4http11url_contentE:
  130|      1|  {
  131|      1|    STATIC_REGEXP_EXPR_1(rexp_match_uri, "^(([^:]*?)://)?(\\[(.*)\\](:(\\d+))?)(.*)?", boost::regex::icase | boost::regex::normal);
  ------------------
  |  |   49|      1|	static std::atomic<bool> regexp_initialized_1(false);\
  |  |   50|      1|	volatile uint32_t local_is_initialized_1 = regexp_initialized_1;\
  |  |   51|      1|	if(!local_is_initialized_1)\
  |  |  ------------------
  |  |  |  Branch (51:5): [True: 1, False: 0]
  |  |  ------------------
  |  |   52|      1|	gregexplock.get_lock().lock();\
  |  |   53|      1|	static const boost::regex	var_name(xpr_text , reg_exp_flags);\
  |  |   54|      1|	if(!local_is_initialized_1)\
  |  |  ------------------
  |  |  |  Branch (54:5): [True: 1, False: 0]
  |  |  ------------------
  |  |   55|      1|{\
  |  |   56|      1|	regexp_initialized_1 = true;\
  |  |   57|      1|	gregexplock.get_lock().unlock();\
  |  |   58|      1|}
  ------------------
  132|       |    //                                     12            3   4      5 6        7
  133|       |
  134|      1|    content.port = 0;
  135|      1|    boost::smatch result;
  136|      1|    if(!(boost::regex_search(url_str, result, rexp_match_uri, boost::match_default) && result[0].matched))
  ------------------
  |  Branch (136:10): [True: 0, False: 1]
  |  Branch (136:88): [True: 0, False: 0]
  ------------------
  137|      1|    {
  138|      1|      LOG_PRINT_L1("[PARSE URI] regex not matched for uri: " << rexp_match_uri);
  ------------------
  |  |  102|      1|#define LOG_PRINT_L1(x) MINFO(x)
  |  |  ------------------
  |  |  |  |   77|      1|#define MINFO(x) MCINFO(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|      1|#define MCINFO(cat,x) MCLOG(el::Level::Info,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      1|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|      1|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|      1|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 1]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|      1|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  139|       |      //content.m_path = uri;
  140|      1|      return false;
  141|      1|    }
  142|      0|    if(result[2].matched)
  ------------------
  |  Branch (142:8): [True: 0, False: 0]
  ------------------
  143|      0|    {
  144|      0|      content.schema = result[2];
  145|      0|    }
  146|      0|    if(result[4].matched)
  ------------------
  |  Branch (146:8): [True: 0, False: 0]
  ------------------
  147|      0|    {
  148|      0|      content.host = result[4];
  149|      0|    }
  150|      0|    else  // if host not matched, matching should be considered failed
  151|      0|    {
  152|      0|      return false;
  153|      0|    }
  154|      0|    if(result[6].matched)
  ------------------
  |  Branch (154:8): [True: 0, False: 0]
  ------------------
  155|      0|    {
  156|      0|      content.port = boost::lexical_cast<uint64_t>(result[6]);
  157|      0|    }
  158|      0|    if(result[7].matched)
  ------------------
  |  Branch (158:8): [True: 0, False: 0]
  ------------------
  159|      0|    {
  160|      0|      content.uri = result[7];
  161|      0|      return parse_uri(result[7], content.m_uri_content);
  162|      0|    }
  163|       |
  164|      0|    return true;
  165|      0|  }
_ZN4epee9net_utils9parse_urlENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERNS0_4http11url_contentE:
  168|      1|  {
  169|       |
  170|      1|    if (parse_url_ipv6(url_str, content)) return true;
  ------------------
  |  Branch (170:9): [True: 0, False: 1]
  ------------------
  171|       |
  172|       |    ///iframe_test.html?api_url=http://api.vk.com/api.php&api_id=3289090&api_settings=1&viewer_id=562964060&viewer_type=0&sid=0aad8d1c5713130f9ca0076f2b7b47e532877424961367d81e7fa92455f069be7e21bc3193cbd0be11895&secret=368ebbc0ef&access_token=668bc03f43981d883f73876ffff4aa8564254b359cc745dfa1b3cde7bdab2e94105d8f6d8250717569c0a7&user_id=0&group_id=0&is_app_user=1&auth_key=d2f7a895ca5ff3fdb2a2a8ae23fe679a&language=0&parent_language=0&ad_info=ElsdCQBaQlxiAQRdFUVUXiN2AVBzBx5pU1BXIgZUJlIEAWcgAUoLQg==&referrer=unknown&lc_name=9834b6a3&hash=
  173|       |    //STATIC_REGEXP_EXPR_1(rexp_match_uri, "^([^?#]*)(\\?([^#]*))?(#(.*))?", boost::regex::icase | boost::regex::normal);
  174|      1|    STATIC_REGEXP_EXPR_1(rexp_match_uri, "^(([^:]*?)://)?(([^/:]*)(:(\\d+))?)(.*)?", boost::regex::icase | boost::regex::normal);
  ------------------
  |  |   49|      1|	static std::atomic<bool> regexp_initialized_1(false);\
  |  |   50|      1|	volatile uint32_t local_is_initialized_1 = regexp_initialized_1;\
  |  |   51|      1|	if(!local_is_initialized_1)\
  |  |  ------------------
  |  |  |  Branch (51:5): [True: 1, False: 0]
  |  |  ------------------
  |  |   52|      1|	gregexplock.get_lock().lock();\
  |  |   53|      1|	static const boost::regex	var_name(xpr_text , reg_exp_flags);\
  |  |   54|      1|	if(!local_is_initialized_1)\
  |  |  ------------------
  |  |  |  Branch (54:5): [True: 1, False: 0]
  |  |  ------------------
  |  |   55|      1|{\
  |  |   56|      1|	regexp_initialized_1 = true;\
  |  |   57|      1|	gregexplock.get_lock().unlock();\
  |  |   58|      1|}
  ------------------
  175|       |    //                                     12            34       5 6        7
  176|      1|    content.port = 0;
  177|      1|    boost::smatch result;	
  178|      1|    if(!(boost::regex_search(url_str, result, rexp_match_uri, boost::match_default) && result[0].matched))
  ------------------
  |  Branch (178:10): [True: 1, False: 0]
  |  Branch (178:88): [True: 1, False: 0]
  ------------------
  179|      0|    {
  180|      0|      LOG_PRINT_L1("[PARSE URI] regex not matched for uri: " << rexp_match_uri);
  ------------------
  |  |  102|      0|#define LOG_PRINT_L1(x) MINFO(x)
  |  |  ------------------
  |  |  |  |   77|      0|#define MINFO(x) MCINFO(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|      0|#define MCINFO(cat,x) MCLOG(el::Level::Info,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  181|       |      //content.m_path = uri;
  182|      0|      return true;
  183|      0|    }
  184|      1|    if(result[2].matched)
  ------------------
  |  Branch (184:8): [True: 1, False: 0]
  ------------------
  185|      1|    {
  186|      1|      content.schema = result[2];
  187|      1|    }
  188|      1|    if(result[4].matched)
  ------------------
  |  Branch (188:8): [True: 1, False: 0]
  ------------------
  189|      1|    {
  190|      1|      content.host = result[4];
  191|      1|    }
  192|      1|    if(result[6].matched)
  ------------------
  |  Branch (192:8): [True: 1, False: 0]
  ------------------
  193|      1|    {
  194|      1|      content.port = boost::lexical_cast<uint64_t>(result[6]);
  195|      1|    }
  196|      1|    if(result[7].matched)
  ------------------
  |  Branch (196:8): [True: 1, False: 0]
  ------------------
  197|      1|    {
  198|      1|      content.uri = result[7];
  199|      1|      return parse_uri(result[7], content.m_uri_content);
  200|      1|    }
  201|       |    
  202|      0|    return true;
  203|      1|  }

_ZN4epee12string_tools13get_extensionERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  180|      1|  {
  181|      1|    std::string ext_with_dot = boost::filesystem::path(str).extension().string();
  182|       |
  183|      1|    if (ext_with_dot.empty())
  ------------------
  |  Branch (183:9): [True: 1, False: 0]
  ------------------
  184|      1|      return {};
  185|       |
  186|      0|    return ext_with_dot.erase(0, 1);
  187|      1|  }

_ZN4epee15wipeable_stringC2ERKS0_:
   52|      2|  buffer(other.buffer)
   53|      2|{
   54|      2|}
_ZN4epee15wipeable_stringC2EONSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   71|      2|{
   72|      2|  grow(other.size());
   73|      2|  if (size() > 0)
  ------------------
  |  Branch (73:7): [True: 2, False: 0]
  ------------------
   74|      2|    memcpy(buffer.data(), other.c_str(), size());
   75|      2|  if (!other.empty())
  ------------------
  |  Branch (75:7): [True: 2, False: 0]
  ------------------
   76|      2|  {
   77|      2|    memwipe(&other[0], other.size()); // we're kinda left with this again aren't we
   78|      2|    other = std::string();
   79|      2|  }
   80|      2|}
_ZN4epee15wipeable_stringC2EPKc:
   83|      1|{
   84|      1|  grow(strlen(s));
   85|      1|  if (size() > 0)
  ------------------
  |  Branch (85:7): [True: 0, False: 1]
  ------------------
   86|      0|    memcpy(buffer.data(), s, size());
   87|      1|}
_ZN4epee15wipeable_stringD2Ev:
   96|      6|{
   97|      6|  wipe();
   98|      6|}
_ZN4epee15wipeable_string4wipeEv:
  101|      6|{
  102|      6|  if (!buffer.empty())
  ------------------
  |  Branch (102:7): [True: 4, False: 2]
  ------------------
  103|      4|    memwipe(buffer.data(), buffer.size() * sizeof(char));
  104|      6|}
_ZN4epee15wipeable_string4growEmm:
  107|      3|{
  108|      3|  if (reserved < sz)
  ------------------
  |  Branch (108:7): [True: 2, False: 1]
  ------------------
  109|      2|    reserved = sz;
  110|      3|  if (reserved <= buffer.capacity())
  ------------------
  |  Branch (110:7): [True: 1, False: 2]
  ------------------
  111|      1|  {
  112|      1|    if (sz < buffer.size())
  ------------------
  |  Branch (112:9): [True: 0, False: 1]
  ------------------
  113|      0|      memwipe(buffer.data() + sz, buffer.size() - sz);
  114|      1|    buffer.resize(sz);
  115|      1|    return;
  116|      1|  }
  117|      2|  size_t old_sz = buffer.size();
  118|      2|  std::unique_ptr<char[]> tmp{new char[old_sz]};
  119|      2|  if (old_sz > 0)
  ------------------
  |  Branch (119:7): [True: 0, False: 2]
  ------------------
  120|      0|  {
  121|      0|    memcpy(tmp.get(), buffer.data(), old_sz * sizeof(char));
  122|      0|    memwipe(buffer.data(), old_sz * sizeof(char));
  123|      0|  }
  124|      2|  buffer.reserve(reserved);
  125|      2|  buffer.resize(sz);
  126|      2|  if (old_sz > 0)
  ------------------
  |  Branch (126:7): [True: 0, False: 2]
  ------------------
  127|      0|  {
  128|      0|    memcpy(buffer.data(), tmp.get(), old_sz * sizeof(char));
  129|      0|    memwipe(tmp.get(), old_sz * sizeof(char));
  130|      0|  }
  131|      2|}

_ZN2el4base5debug12CrashHandlerC2Eb:
 3310|      2|CrashHandler::CrashHandler(bool useDefault) {
 3311|      2|  if (useDefault) {
  ------------------
  |  Branch (3311:7): [True: 0, False: 2]
  ------------------
 3312|      0|    setHandler(defaultCrashHandler);
 3313|      0|  }
 3314|      2|}
_ZN2el11LevelHelper12forEachLevelEPjRKNSt3__18functionIFbvEEE:
  251|   467k|void LevelHelper::forEachLevel(base::type::EnumType* startIndex, const std::function<bool(void)>& fn) {
  252|   467k|  base::type::EnumType lIndexMax = LevelHelper::kMaxValid;
  253|  3.27M|  do {
  254|  3.27M|    if (fn()) {
  ------------------
  |  Branch (254:9): [True: 0, False: 3.27M]
  ------------------
  255|      0|      break;
  256|      0|    }
  257|  3.27M|    *startIndex = static_cast<base::type::EnumType>(*startIndex << 1);
  258|  3.27M|  } while (*startIndex <= lIndexMax);
  ------------------
  |  Branch (258:12): [True: 2.80M, False: 467k]
  ------------------
  259|   467k|}
_ZN2el13ConfigurationC2ENS_5LevelENS_17ConfigurationTypeERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  333|  1.40M|  m_level(level),
  334|  1.40M|  m_configurationType(configurationType),
  335|  1.40M|  m_value(value) {
  336|  1.40M|}
_ZN2el13Configuration9PredicateC2ENS_5LevelENS_17ConfigurationTypeE:
  346|  3.90M|  m_level(level),
  347|  3.90M|  m_configurationType(configurationType) {
  348|  3.90M|}
_ZNK2el13Configuration9PredicateclEPKS0_:
  350|   144M|bool Configuration::Predicate::operator()(const Configuration* conf) const {
  351|   144M|  return ((conf != nullptr) && (conf->level() == m_level) && (conf->configurationType() == m_configurationType));
  ------------------
  |  Branch (351:11): [True: 144M, False: 0]
  |  Branch (351:32): [True: 18.3M, False: 125M]
  |  Branch (351:62): [True: 2.50M, False: 15.8M]
  ------------------
  352|   144M|}
_ZN2el14ConfigurationsC2Ev:
  357|  19.4k|  m_configurationFile(std::string()),
  358|  19.4k|  m_isFromFile(false) {
  359|  19.4k|}
_ZN2el14Configurations11setFromBaseEPS0_:
  393|  9.74k|void Configurations::setFromBase(Configurations* base) {
  394|  9.74k|  if (base == nullptr || base == this) {
  ------------------
  |  Branch (394:7): [True: 0, False: 9.74k]
  |  Branch (394:26): [True: 0, False: 9.74k]
  ------------------
  395|      0|    return;
  396|      0|  }
  397|  9.74k|  base::threading::ScopedLock scopedLock(base->lock());
  398|   701k|  for (Configuration*& conf : base->list()) {
  ------------------
  |  Branch (398:29): [True: 701k, False: 9.74k]
  ------------------
  399|   701k|    set(conf);
  400|   701k|  }
  401|  9.74k|}
_ZN2el14Configurations3setENS_5LevelENS_17ConfigurationTypeERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  426|  1.45M|void Configurations::set(Level level, ConfigurationType configurationType, const std::string& value) {
  427|  1.45M|  base::threading::ScopedLock scopedLock(lock());
  428|  1.45M|  unsafeSet(level, configurationType, value);  // This is not unsafe anymore as we have locked mutex
  429|  1.45M|  if (level == Level::Global) {
  ------------------
  |  Branch (429:7): [True: 175k, False: 1.27M]
  ------------------
  430|   175k|    unsafeSetGlobally(configurationType, value, false);  // Again this is not unsafe either
  431|   175k|  }
  432|  1.45M|}
_ZN2el14Configurations3setEPNS_13ConfigurationE:
  434|   701k|void Configurations::set(Configuration* conf) {
  435|   701k|  if (conf == nullptr) {
  ------------------
  |  Branch (435:7): [True: 0, False: 701k]
  ------------------
  436|      0|    return;
  437|      0|  }
  438|   701k|  set(conf->level(), conf->configurationType(), conf->value());
  439|   701k|}
_ZN2el14Configurations12setToDefaultEv:
  441|  9.74k|void Configurations::setToDefault(void) {
  442|  9.74k|  setGlobally(ConfigurationType::Enabled, std::string("true"), true);
  443|  9.74k|  setGlobally(ConfigurationType::Filename, std::string(base::consts::kDefaultLogFile), true);
  444|       |#if defined(ELPP_NO_LOG_TO_FILE)
  445|       |  setGlobally(ConfigurationType::ToFile, std::string("false"), true);
  446|       |#else
  447|  9.74k|  setGlobally(ConfigurationType::ToFile, std::string("true"), true);
  448|  9.74k|#endif // defined(ELPP_NO_LOG_TO_FILE)
  449|  9.74k|  setGlobally(ConfigurationType::ToStandardOutput, std::string("true"), true);
  450|  9.74k|  setGlobally(ConfigurationType::SubsecondPrecision, std::string("3"), true);
  451|  9.74k|  setGlobally(ConfigurationType::PerformanceTracking, std::string("true"), true);
  452|  9.74k|  setGlobally(ConfigurationType::MaxLogFileSize, std::string("0"), true);
  453|  9.74k|  setGlobally(ConfigurationType::LogFlushThreshold, std::string("0"), true);
  454|       |
  455|  9.74k|  setGlobally(ConfigurationType::Format, std::string("%datetime %level [%logger] %msg"), true);
  456|  9.74k|  set(Level::Debug, ConfigurationType::Format,
  457|  9.74k|      std::string("%datetime %level [%logger] [%user@%host] [%func] [%loc] %msg"));
  458|       |  // INFO and WARNING are set to default by Level::Global
  459|  9.74k|  set(Level::Error, ConfigurationType::Format, std::string("%datetime %level [%logger] %msg"));
  460|  9.74k|  set(Level::Fatal, ConfigurationType::Format, std::string("%datetime %level [%logger] %msg"));
  461|  9.74k|  set(Level::Verbose, ConfigurationType::Format, std::string("%datetime %level-%vlevel [%logger] %msg"));
  462|  9.74k|  set(Level::Trace, ConfigurationType::Format, std::string("%datetime %level [%logger] [%func] [%loc] %msg"));
  463|  9.74k|}
_ZN2el14Configurations9unsafeSetENS_5LevelENS_17ConfigurationTypeERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  624|  3.90M|void Configurations::unsafeSet(Level level, ConfigurationType configurationType, const std::string& value) {
  625|  3.90M|  Configuration* conf = RegistryWithPred<Configuration, Configuration::Predicate>::get(level, configurationType);
  626|  3.90M|  if (conf == nullptr) {
  ------------------
  |  Branch (626:7): [True: 1.40M, False: 2.50M]
  ------------------
  627|  1.40M|    registerNew(new Configuration(level, configurationType, value));
  628|  2.50M|  } else {
  629|  2.50M|    conf->setValue(value);
  630|  2.50M|  }
  631|  3.90M|  if (level == Level::Global) {
  ------------------
  |  Branch (631:7): [True: 175k, False: 3.73M]
  ------------------
  632|   175k|    unsafeSetGlobally(configurationType, value, false);
  633|   175k|  }
  634|  3.90M|}
_ZN2el14Configurations11setGloballyENS_17ConfigurationTypeERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEb:
  637|  87.7k|                                 bool includeGlobalLevel) {
  638|  87.7k|  if (includeGlobalLevel) {
  ------------------
  |  Branch (638:7): [True: 87.7k, False: 0]
  ------------------
  639|  87.7k|    set(Level::Global, configurationType, value);
  640|  87.7k|  }
  641|  87.7k|  base::type::EnumType lIndex = LevelHelper::kMinValid;
  642|  87.7k|  LevelHelper::forEachLevel(&lIndex, [&](void) -> bool {
  643|  87.7k|    set(LevelHelper::castFromInt(lIndex), configurationType, value);
  644|  87.7k|    return false;  // Do not break lambda function yet as we need to set all levels regardless
  645|  87.7k|  });
  646|  87.7k|}
_ZN2el14Configurations17unsafeSetGloballyENS_17ConfigurationTypeERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEb:
  649|   350k|                                       bool includeGlobalLevel) {
  650|   350k|  if (includeGlobalLevel) {
  ------------------
  |  Branch (650:7): [True: 0, False: 350k]
  ------------------
  651|      0|    unsafeSet(Level::Global, configurationType, value);
  652|      0|  }
  653|   350k|  base::type::EnumType lIndex = LevelHelper::kMinValid;
  654|   350k|  LevelHelper::forEachLevel(&lIndex, [&](void) -> bool  {
  655|   350k|    unsafeSet(LevelHelper::castFromInt(lIndex), configurationType, value);
  656|   350k|    return false;  // Do not break lambda function yet as we need to set all levels regardless
  657|   350k|  });
  658|   350k|}
_ZN2el6LoggerC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS_14ConfigurationsEPNS1_13unordered_mapIS7_NS1_10shared_ptrINS1_13basic_fstreamIcS4_EEEENS1_4hashIS7_EENS1_8equal_toIS7_EENS5_INS1_4pairIS8_SH_EEEEEE:
  712|  9.74k|  m_id(id),
  713|  9.74k|  m_typedConfigurations(nullptr),
  714|  9.74k|  m_parentApplicationName(std::string()),
  715|  9.74k|  m_isConfigured(false),
  716|  9.74k|  m_logStreamsReference(logStreamsReference) {
  717|  9.74k|  initUnflushedCount();
  718|  9.74k|  configure(configurations);
  719|  9.74k|}
_ZN2el6Logger9configureERKNS_14ConfigurationsE:
  745|  9.74k|void Logger::configure(const Configurations& configurations) {
  746|  9.74k|  m_isConfigured = false;  // we set it to false in case if we fail
  747|  9.74k|  initUnflushedCount();
  748|  9.74k|  if (m_typedConfigurations != nullptr) {
  ------------------
  |  Branch (748:7): [True: 0, False: 9.74k]
  ------------------
  749|      0|    Configurations* c = const_cast<Configurations*>(m_typedConfigurations->configurations());
  750|      0|    if (c->hasConfiguration(Level::Global, ConfigurationType::Filename)) {
  ------------------
  |  Branch (750:9): [True: 0, False: 0]
  ------------------
  751|      0|      flush();
  752|      0|    }
  753|      0|  }
  754|  9.74k|  base::threading::ScopedLock scopedLock(lock());
  755|  9.74k|  if (m_configurations != configurations) {
  ------------------
  |  Branch (755:7): [True: 9.74k, False: 0]
  ------------------
  756|  9.74k|    m_configurations.setFromBase(const_cast<Configurations*>(&configurations));
  757|  9.74k|  }
  758|  9.74k|  base::utils::safeDelete(m_typedConfigurations);
  759|  9.74k|  m_typedConfigurations = new base::TypedConfigurations(&m_configurations, m_logStreamsReference);
  760|  9.74k|  resolveLoggerFormatSpec();
  761|  9.74k|  m_isConfigured = true;
  762|  9.74k|}
_ZN2el6Logger9isValidIdERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  769|  9.74k|bool Logger::isValidId(const std::string& id) {
  770|  77.9k|  for (std::string::const_iterator it = id.begin(); it != id.end(); ++it) {
  ------------------
  |  Branch (770:53): [True: 68.2k, False: 9.74k]
  ------------------
  771|  68.2k|    if (!base::utils::Str::contains(base::consts::kValidLoggerIdSymbols, *it)) {
  ------------------
  |  Branch (771:9): [True: 0, False: 68.2k]
  ------------------
  772|      0|      return false;
  773|      0|    }
  774|  68.2k|  }
  775|  9.74k|  return true;
  776|  9.74k|}
_ZN2el6Logger18initUnflushedCountEv:
  802|  19.4k|void Logger::initUnflushedCount(void) {
  803|  19.4k|  m_unflushedCount.clear();
  804|  19.4k|  base::type::EnumType lIndex = LevelHelper::kMinValid;
  805|  19.4k|  LevelHelper::forEachLevel(&lIndex, [&](void) -> bool {
  806|  19.4k|    m_unflushedCount.insert(std::make_pair(LevelHelper::castFromInt(lIndex), 0));
  807|  19.4k|    return false;
  808|  19.4k|  });
  809|  19.4k|}
_ZNK2el6Logger23resolveLoggerFormatSpecEv:
  811|  9.74k|void Logger::resolveLoggerFormatSpec(void) const {
  812|  9.74k|  base::type::EnumType lIndex = LevelHelper::kMinValid;
  813|  9.74k|  LevelHelper::forEachLevel(&lIndex, [&](void) -> bool {
  814|  9.74k|    base::LogFormat* logFormat =
  815|  9.74k|    const_cast<base::LogFormat*>(&m_typedConfigurations->logFormat(LevelHelper::castFromInt(lIndex)));
  816|  9.74k|    base::utils::Str::replaceFirstWithEscape(logFormat->m_format, base::consts::kLoggerIdFormatSpecifier, m_id);
  817|  9.74k|    return false;
  818|  9.74k|  });
  819|  9.74k|}
_ZN2el4base5utils3Str5ltrimERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  988|   545k|std::string& Str::ltrim(std::string& str) {
  989|   545k|  str.erase(str.begin(), std::find_if(str.begin(), str.end(), [](char c) {
  990|   545k|    return !std::isspace(c);
  991|   545k|  } ));
  992|   545k|  return str;
  993|   545k|}
_ZN2el4base5utils3Str5rtrimERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  995|   545k|std::string& Str::rtrim(std::string& str) {
  996|   545k|  str.erase(std::find_if(str.rbegin(), str.rend(), [](char c) {
  997|   545k|    return !std::isspace(c);
  998|   545k|  }).base(), str.end());
  999|   545k|  return str;
 1000|   545k|}
_ZN2el4base5utils3Str4trimERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
 1002|   545k|std::string& Str::trim(std::string& str) {
 1003|   545k|  return ltrim(rtrim(str));
 1004|   545k|}
_ZN2el4base5utils3Str22replaceFirstWithEscapeERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERKS9_SC_:
 1031|   224k|                                 const base::type::string_t& replaceWith) {
 1032|   224k|  std::size_t foundAt = base::type::string_t::npos;
 1033|   224k|  while ((foundAt = str.find(replaceWhat, foundAt + 1)) != base::type::string_t::npos) {
  ------------------
  |  Branch (1033:10): [True: 155k, False: 68.2k]
  ------------------
 1034|   155k|    if (foundAt > 0 && str[foundAt - 1] == base::consts::kFormatSpecifierChar) {
  ------------------
  |  Branch (1034:9): [True: 155k, False: 0]
  |  Branch (1034:24): [True: 0, False: 155k]
  ------------------
 1035|      0|      str.erase(foundAt - 1, 1);
 1036|      0|      ++foundAt;
 1037|   155k|    } else {
 1038|   155k|      str.replace(foundAt, replaceWhat.length(), replaceWith);
 1039|   155k|      return;
 1040|   155k|    }
 1041|   155k|  }
 1042|   224k|}
_ZN2el4base5utils3Str8containsEPKcc:
 1083|  68.2k|bool Str::contains(const char* str, char c) {
 1084|   672k|  for (; *str; ++str) {
  ------------------
  |  Branch (1084:10): [True: 672k, False: 0]
  ------------------
 1085|   672k|    if (*str == c)
  ------------------
  |  Branch (1085:9): [True: 68.2k, False: 604k]
  ------------------
 1086|  68.2k|      return true;
 1087|   672k|  }
 1088|      0|  return false;
 1089|  68.2k|}
_ZN2el4base5utils2OS22getEnvironmentVariableEPKcS4_S4_:
 1198|   165k|                                       const char* alternativeBashCommand) {
 1199|   165k|#if ELPP_OS_UNIX
 1200|   165k|  const char* val = getenv(variableName);
 1201|       |#elif ELPP_OS_WINDOWS
 1202|       |  const char* val = getWindowsEnvironmentVariable(variableName);
 1203|       |#endif  // ELPP_OS_UNIX
 1204|   165k|  if ((val == nullptr) || ((strcmp(val, "") == 0))) {
  ------------------
  |  Branch (1204:7): [True: 87.7k, False: 77.9k]
  |  Branch (1204:27): [True: 0, False: 77.9k]
  ------------------
 1205|       |#if ELPP_OS_UNIX && defined(ELPP_FORCE_ENV_VAR_FROM_BASH)
 1206|       |    // Try harder on unix-based systems
 1207|       |    std::string valBash = base::utils::OS::getBashOutput(alternativeBashCommand);
 1208|       |    if (valBash.empty()) {
 1209|       |      return std::string(defaultVal);
 1210|       |    } else {
 1211|       |      return valBash;
 1212|       |    }
 1213|       |#elif ELPP_OS_WINDOWS || ELPP_OS_UNIX
 1214|  87.7k|    ELPP_UNUSED(alternativeBashCommand);
  ------------------
  |  |  240|  87.7k|#define ELPP_UNUSED(x) (void)x
  ------------------
 1215|  87.7k|    return std::string(defaultVal);
 1216|  87.7k|#endif  // ELPP_OS_UNIX && defined(ELPP_FORCE_ENV_VAR_FROM_BASH)
 1217|  87.7k|  }
 1218|  77.9k|  return std::string(val);
 1219|   165k|}
_ZN2el4base5utils2OS11currentUserEv:
 1221|  77.9k|std::string OS::currentUser(void) {
 1222|  77.9k|#if ELPP_OS_UNIX && !ELPP_OS_ANDROID
 1223|  77.9k|  return getEnvironmentVariable("USER", base::consts::kUnknownUser, "whoami");
 1224|       |#elif ELPP_OS_WINDOWS
 1225|       |  return getEnvironmentVariable("USERNAME", base::consts::kUnknownUser);
 1226|       |#elif ELPP_OS_ANDROID
 1227|       |  ELPP_UNUSED(base::consts::kUnknownUser);
 1228|       |  return std::string("android");
 1229|       |#else
 1230|       |  return std::string();
 1231|       |#endif  // ELPP_OS_UNIX && !ELPP_OS_ANDROID
 1232|  77.9k|}
_ZN2el4base5utils2OS11currentHostEv:
 1234|  77.9k|std::string OS::currentHost(void) {
 1235|  77.9k|#if ELPP_OS_UNIX && !ELPP_OS_ANDROID
 1236|  77.9k|  return getEnvironmentVariable("HOSTNAME", base::consts::kUnknownHost, "hostname");
 1237|       |#elif ELPP_OS_WINDOWS
 1238|       |  return getEnvironmentVariable("COMPUTERNAME", base::consts::kUnknownHost);
 1239|       |#elif ELPP_OS_ANDROID
 1240|       |  ELPP_UNUSED(base::consts::kUnknownHost);
 1241|       |  return getDeviceName();
 1242|       |#else
 1243|       |  return std::string();
 1244|       |#endif  // ELPP_OS_UNIX && !ELPP_OS_ANDROID
 1245|  77.9k|}
_ZN2el4base5utils2OS17termSupportsColorEv:
 1247|  9.74k|bool OS::termSupportsColor(void) {
 1248|  9.74k|  std::string term = getEnvironmentVariable("TERM", "");
 1249|  9.74k|  return term == "xterm" || term == "xterm-color" || term == "xterm-256color"
  ------------------
  |  Branch (1249:10): [True: 0, False: 9.74k]
  |  Branch (1249:29): [True: 0, False: 9.74k]
  |  Branch (1249:54): [True: 0, False: 9.74k]
  ------------------
 1250|  9.74k|         || term == "screen" || term == "linux" || term == "cygwin"
  ------------------
  |  Branch (1250:13): [True: 0, False: 9.74k]
  |  Branch (1250:33): [True: 0, False: 9.74k]
  |  Branch (1250:52): [True: 0, False: 9.74k]
  ------------------
 1251|  9.74k|         || term == "screen-256color" || term == "screen.xterm-256color";
  ------------------
  |  Branch (1251:13): [True: 0, False: 9.74k]
  |  Branch (1251:42): [True: 0, False: 9.74k]
  ------------------
 1252|  9.74k|}
_ZN2el4base5utils15CommandLineArgs7setArgsEiPPc:
 1423|  9.74k|void CommandLineArgs::setArgs(int argc, char** argv) {
 1424|  9.74k|  m_params.clear();
 1425|  9.74k|  m_paramsWithValue.clear();
 1426|  9.74k|  if (argc == 0 || argv == nullptr) {
  ------------------
  |  Branch (1426:7): [True: 9.74k, False: 0]
  |  Branch (1426:20): [True: 0, False: 0]
  ------------------
 1427|  9.74k|    return;
 1428|  9.74k|  }
 1429|      0|  m_argc = argc;
 1430|      0|  m_argv = argv;
 1431|      0|  for (int i = 1; i < m_argc; ++i) {
  ------------------
  |  Branch (1431:19): [True: 0, False: 0]
  ------------------
 1432|      0|    const char* v = (strstr(m_argv[i], "="));
 1433|      0|    if (v != nullptr && strlen(v) > 0) {
  ------------------
  |  Branch (1433:9): [True: 0, False: 0]
  |  Branch (1433:25): [True: 0, False: 0]
  ------------------
 1434|      0|      std::string key = std::string(m_argv[i]);
 1435|      0|      key = key.substr(0, key.find_first_of('='));
 1436|      0|      if (hasParamWithValue(key.c_str())) {
  ------------------
  |  Branch (1436:11): [True: 0, False: 0]
  ------------------
 1437|      0|        ELPP_INTERNAL_INFO(1, "Skipping [" << key << "] arg since it already has value ["
 1438|      0|                           << getParamValue(key.c_str()) << "]");
 1439|      0|      } else {
 1440|      0|        m_paramsWithValue.insert(std::make_pair(key, std::string(v + 1)));
 1441|      0|      }
 1442|      0|    }
 1443|      0|    if (v == nullptr) {
  ------------------
  |  Branch (1443:9): [True: 0, False: 0]
  ------------------
 1444|      0|      if (hasParam(m_argv[i])) {
  ------------------
  |  Branch (1444:11): [True: 0, False: 0]
  ------------------
 1445|      0|        ELPP_INTERNAL_INFO(1, "Skipping [" << m_argv[i] << "] arg since it already exists");
 1446|      0|      } else {
 1447|      0|        m_params.push_back(std::string(m_argv[i]));
 1448|      0|      }
 1449|      0|    }
 1450|      0|  }
 1451|      0|}
_ZN2el4base18SubsecondPrecision4initEi:
 1510|  77.9k|void SubsecondPrecision::init(int width) {
 1511|  77.9k|  if (width < 1 || width > 6) {
  ------------------
  |  Branch (1511:7): [True: 0, False: 77.9k]
  |  Branch (1511:20): [True: 0, False: 77.9k]
  ------------------
 1512|      0|    width = base::consts::kDefaultSubsecondPrecision;
 1513|      0|  }
 1514|  77.9k|  m_width = width;
 1515|  77.9k|  switch (m_width) {
 1516|  77.9k|  case 3:
  ------------------
  |  Branch (1516:3): [True: 77.9k, False: 0]
  ------------------
 1517|  77.9k|    m_offset = 1000;
 1518|  77.9k|    break;
 1519|      0|  case 4:
  ------------------
  |  Branch (1519:3): [True: 0, False: 77.9k]
  ------------------
 1520|      0|    m_offset = 100;
 1521|      0|    break;
 1522|      0|  case 5:
  ------------------
  |  Branch (1522:3): [True: 0, False: 77.9k]
  ------------------
 1523|      0|    m_offset = 10;
 1524|      0|    break;
 1525|      0|  case 6:
  ------------------
  |  Branch (1525:3): [True: 0, False: 77.9k]
  ------------------
 1526|      0|    m_offset = 1;
 1527|      0|    break;
 1528|      0|  default:
  ------------------
  |  Branch (1528:3): [True: 0, False: 77.9k]
  ------------------
 1529|      0|    m_offset = 1000;
 1530|      0|    break;
 1531|  77.9k|  }
 1532|  77.9k|}
_ZN2el4base9LogFormatC2ENS_5LevelERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
 1547|  77.9k|  : m_level(level), m_userFormat(format), m_currentUser(base::utils::OS::currentUser()),
 1548|  77.9k|    m_currentHost(base::utils::OS::currentHost()) {
 1549|  77.9k|  parseFromFormat(m_userFormat);
 1550|  77.9k|}
_ZN2el4base9LogFormatC2ERKS1_:
 1553|  77.9k|  m_level(logFormat.m_level),
 1554|  77.9k|  m_userFormat(logFormat.m_userFormat),
 1555|  77.9k|  m_format(logFormat.m_format),
 1556|  77.9k|  m_dateTimeFormat(logFormat.m_dateTimeFormat),
 1557|  77.9k|  m_flags(logFormat.m_flags),
 1558|  77.9k|  m_currentUser(logFormat.m_currentUser),
 1559|  77.9k|  m_currentHost(logFormat.m_currentHost) {
 1560|  77.9k|}
_ZN2el4base9LogFormatC2EOS1_:
 1562|  77.9k|LogFormat::LogFormat(LogFormat&& logFormat) {
 1563|  77.9k|  m_level = std::move(logFormat.m_level);
 1564|  77.9k|  m_userFormat = std::move(logFormat.m_userFormat);
 1565|  77.9k|  m_format = std::move(logFormat.m_format);
 1566|  77.9k|  m_dateTimeFormat = std::move(logFormat.m_dateTimeFormat);
 1567|  77.9k|  m_flags = std::move(logFormat.m_flags);
 1568|  77.9k|  m_currentUser = std::move(logFormat.m_currentUser);
 1569|  77.9k|  m_currentHost = std::move(logFormat.m_currentHost);
 1570|  77.9k|}
_ZN2el4base9LogFormateqERKS1_:
 1584|  68.2k|bool LogFormat::operator==(const LogFormat& other) {
 1585|  68.2k|  return m_level == other.m_level && m_userFormat == other.m_userFormat && m_format == other.m_format &&
  ------------------
  |  Branch (1585:10): [True: 0, False: 68.2k]
  |  Branch (1585:38): [True: 0, False: 0]
  |  Branch (1585:76): [True: 0, False: 0]
  ------------------
 1586|  68.2k|         m_dateTimeFormat == other.m_dateTimeFormat && m_flags == other.m_flags;
  ------------------
  |  Branch (1586:10): [True: 0, False: 0]
  |  Branch (1586:56): [True: 0, False: 0]
  ------------------
 1587|  68.2k|}
_ZN2el4base9LogFormat15parseFromFormatERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
 1591|  77.9k|void LogFormat::parseFromFormat(const base::type::string_t& userFormat) {
 1592|       |  // We make copy because we will be changing the format
 1593|       |  // i.e, removing user provided date format from original format
 1594|       |  // and then storing it.
 1595|  77.9k|  base::type::string_t formatCopy = userFormat;
 1596|  77.9k|  m_flags = 0x0;
 1597|  77.9k|  auto conditionalAddFlag = [&](const base::type::char_t* specifier, base::FormatFlags flag) {
 1598|  77.9k|    std::size_t foundAt = base::type::string_t::npos;
 1599|  77.9k|    while ((foundAt = formatCopy.find(specifier, foundAt + 1)) != base::type::string_t::npos) {
 1600|  77.9k|      if (foundAt > 0 && formatCopy[foundAt - 1] == base::consts::kFormatSpecifierChar) {
 1601|  77.9k|        if (hasFlag(flag)) {
 1602|       |          // If we already have flag we remove the escape chars so that '%%' is turned to '%'
 1603|       |          // even after specifier resolution - this is because we only replaceFirst specifier
 1604|  77.9k|          formatCopy.erase(foundAt - 1, 1);
 1605|  77.9k|          ++foundAt;
 1606|  77.9k|        }
 1607|  77.9k|      } else {
 1608|  77.9k|        if (!hasFlag(flag)) addFlag(flag);
 1609|  77.9k|      }
 1610|  77.9k|    }
 1611|  77.9k|  };
 1612|  77.9k|  conditionalAddFlag(base::consts::kAppNameFormatSpecifier, base::FormatFlags::AppName);
 1613|  77.9k|  conditionalAddFlag(base::consts::kSeverityLevelFormatSpecifier, base::FormatFlags::Level);
 1614|  77.9k|  conditionalAddFlag(base::consts::kSeverityLevelShortFormatSpecifier, base::FormatFlags::LevelShort);
 1615|  77.9k|  conditionalAddFlag(base::consts::kLoggerIdFormatSpecifier, base::FormatFlags::LoggerId);
 1616|  77.9k|  conditionalAddFlag(base::consts::kThreadIdFormatSpecifier, base::FormatFlags::ThreadId);
 1617|  77.9k|  conditionalAddFlag(base::consts::kLogFileFormatSpecifier, base::FormatFlags::File);
 1618|  77.9k|  conditionalAddFlag(base::consts::kLogFileBaseFormatSpecifier, base::FormatFlags::FileBase);
 1619|  77.9k|  conditionalAddFlag(base::consts::kLogLineFormatSpecifier, base::FormatFlags::Line);
 1620|  77.9k|  conditionalAddFlag(base::consts::kLogLocationFormatSpecifier, base::FormatFlags::Location);
 1621|  77.9k|  conditionalAddFlag(base::consts::kLogFunctionFormatSpecifier, base::FormatFlags::Function);
 1622|  77.9k|  conditionalAddFlag(base::consts::kCurrentUserFormatSpecifier, base::FormatFlags::User);
 1623|  77.9k|  conditionalAddFlag(base::consts::kCurrentHostFormatSpecifier, base::FormatFlags::Host);
 1624|  77.9k|  conditionalAddFlag(base::consts::kMessageFormatSpecifier, base::FormatFlags::LogMessage);
 1625|  77.9k|  conditionalAddFlag(base::consts::kVerboseLevelFormatSpecifier, base::FormatFlags::VerboseLevel);
 1626|       |  // For date/time we need to extract user's date format first
 1627|  77.9k|  std::size_t dateIndex = std::string::npos;
 1628|  77.9k|  if ((dateIndex = formatCopy.find(base::consts::kDateTimeFormatSpecifier)) != std::string::npos) {
  ------------------
  |  Branch (1628:7): [True: 77.9k, False: 0]
  ------------------
 1629|  77.9k|    while (dateIndex > 0 && formatCopy[dateIndex - 1] == base::consts::kFormatSpecifierChar) {
  ------------------
  |  Branch (1629:12): [True: 0, False: 77.9k]
  |  Branch (1629:29): [True: 0, False: 0]
  ------------------
 1630|      0|      dateIndex = formatCopy.find(base::consts::kDateTimeFormatSpecifier, dateIndex + 1);
 1631|      0|    }
 1632|  77.9k|    if (dateIndex != std::string::npos) {
  ------------------
  |  Branch (1632:9): [True: 77.9k, False: 0]
  ------------------
 1633|  77.9k|      addFlag(base::FormatFlags::DateTime);
 1634|  77.9k|      updateDateFormat(dateIndex, formatCopy);
 1635|  77.9k|    }
 1636|  77.9k|  }
 1637|  77.9k|  m_format = formatCopy;
 1638|  77.9k|  updateFormatSpec();
 1639|  77.9k|}
_ZN2el4base9LogFormat16updateDateFormatEmRNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
 1641|  77.9k|void LogFormat::updateDateFormat(std::size_t index, base::type::string_t& currFormat) {
 1642|  77.9k|  if (hasFlag(base::FormatFlags::DateTime)) {
  ------------------
  |  Branch (1642:7): [True: 77.9k, False: 0]
  ------------------
 1643|  77.9k|    index += ELPP_STRLEN(base::consts::kDateTimeFormatSpecifier);
  ------------------
  |  |  540|  77.9k|#  define ELPP_STRLEN strlen
  ------------------
 1644|  77.9k|  }
 1645|  77.9k|  const base::type::char_t* ptr = currFormat.c_str() + index;
 1646|  77.9k|  if ((currFormat.size() > index) && (ptr[0] == '{')) {
  ------------------
  |  Branch (1646:7): [True: 77.9k, False: 0]
  |  Branch (1646:38): [True: 0, False: 77.9k]
  ------------------
 1647|       |    // User has provided format for date/time
 1648|      0|    ++ptr;
 1649|      0|    int count = 1;  // Start by 1 in order to remove starting brace
 1650|      0|    std::stringstream ss;
 1651|      0|    for (; *ptr; ++ptr, ++count) {
  ------------------
  |  Branch (1651:12): [True: 0, False: 0]
  ------------------
 1652|      0|      if (*ptr == '}') {
  ------------------
  |  Branch (1652:11): [True: 0, False: 0]
  ------------------
 1653|      0|        ++count;  // In order to remove ending brace
 1654|      0|        break;
 1655|      0|      }
 1656|      0|      ss << static_cast<char>(*ptr);
 1657|      0|    }
 1658|      0|    currFormat.erase(index, count);
 1659|      0|    m_dateTimeFormat = ss.str();
 1660|  77.9k|  } else {
 1661|       |    // No format provided, use default
 1662|  77.9k|    if (hasFlag(base::FormatFlags::DateTime)) {
  ------------------
  |  Branch (1662:9): [True: 77.9k, False: 0]
  ------------------
 1663|  77.9k|      m_dateTimeFormat = std::string(base::consts::kDefaultDateTimeFormat);
 1664|  77.9k|    }
 1665|  77.9k|  }
 1666|  77.9k|}
_ZN2el4base9LogFormat16updateFormatSpecEv:
 1668|  77.9k|void LogFormat::updateFormatSpec(void) {
 1669|       |  // Do not use switch over strongly typed enums because Intel C++ compilers dont support them yet.
 1670|  77.9k|  if (m_level == Level::Debug) {
  ------------------
  |  Branch (1670:7): [True: 9.74k, False: 68.2k]
  ------------------
 1671|  9.74k|    base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier,
 1672|  9.74k|        base::consts::kDebugLevelLogValue);
 1673|  9.74k|    base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier,
 1674|  9.74k|        base::consts::kDebugLevelShortLogValue);
 1675|  68.2k|  } else if (m_level == Level::Info) {
  ------------------
  |  Branch (1675:14): [True: 9.74k, False: 58.4k]
  ------------------
 1676|  9.74k|    base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier,
 1677|  9.74k|        base::consts::kInfoLevelLogValue);
 1678|  9.74k|    base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier,
 1679|  9.74k|        base::consts::kInfoLevelShortLogValue);
 1680|  58.4k|  } else if (m_level == Level::Warning) {
  ------------------
  |  Branch (1680:14): [True: 9.74k, False: 48.7k]
  ------------------
 1681|  9.74k|    base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier,
 1682|  9.74k|        base::consts::kWarningLevelLogValue);
 1683|  9.74k|    base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier,
 1684|  9.74k|        base::consts::kWarningLevelShortLogValue);
 1685|  48.7k|  } else if (m_level == Level::Error) {
  ------------------
  |  Branch (1685:14): [True: 9.74k, False: 38.9k]
  ------------------
 1686|  9.74k|    base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier,
 1687|  9.74k|        base::consts::kErrorLevelLogValue);
 1688|  9.74k|    base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier,
 1689|  9.74k|        base::consts::kErrorLevelShortLogValue);
 1690|  38.9k|  } else if (m_level == Level::Fatal) {
  ------------------
  |  Branch (1690:14): [True: 9.74k, False: 29.2k]
  ------------------
 1691|  9.74k|    base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier,
 1692|  9.74k|        base::consts::kFatalLevelLogValue);
 1693|  9.74k|    base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier,
 1694|  9.74k|        base::consts::kFatalLevelShortLogValue);
 1695|  29.2k|  } else if (m_level == Level::Verbose) {
  ------------------
  |  Branch (1695:14): [True: 9.74k, False: 19.4k]
  ------------------
 1696|  9.74k|    base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier,
 1697|  9.74k|        base::consts::kVerboseLevelLogValue);
 1698|  9.74k|    base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier,
 1699|  9.74k|        base::consts::kVerboseLevelShortLogValue);
 1700|  19.4k|  } else if (m_level == Level::Trace) {
  ------------------
  |  Branch (1700:14): [True: 9.74k, False: 9.74k]
  ------------------
 1701|  9.74k|    base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier,
 1702|  9.74k|        base::consts::kTraceLevelLogValue);
 1703|  9.74k|    base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier,
 1704|  9.74k|        base::consts::kTraceLevelShortLogValue);
 1705|  9.74k|  }
 1706|  77.9k|  if (hasFlag(base::FormatFlags::User)) {
  ------------------
  |  Branch (1706:7): [True: 9.74k, False: 68.2k]
  ------------------
 1707|  9.74k|    base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kCurrentUserFormatSpecifier,
 1708|  9.74k|        m_currentUser);
 1709|  9.74k|  }
 1710|  77.9k|  if (hasFlag(base::FormatFlags::Host)) {
  ------------------
  |  Branch (1710:7): [True: 9.74k, False: 68.2k]
  ------------------
 1711|  9.74k|    base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kCurrentHostFormatSpecifier,
 1712|  9.74k|        m_currentHost);
 1713|  9.74k|  }
 1714|       |  // Ignore Level::Global and Level::Unknown
 1715|  77.9k|}
_ZN2el4base19TypedConfigurationsC2EPNS_14ConfigurationsEPNSt3__113unordered_mapINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS4_10shared_ptrINS4_13basic_fstreamIcS8_EEEENS4_4hashISB_EENS4_8equal_toISB_EENS9_INS4_4pairIKSB_SF_EEEEEE:
 1720|  9.74k|    base::LogStreamsReferenceMap* logStreamsReference) {
 1721|  9.74k|  m_configurations = configurations;
 1722|  9.74k|  m_logStreamsReference = logStreamsReference;
 1723|  9.74k|  build(m_configurations);
 1724|  9.74k|}
_ZN2el4base19TypedConfigurations9logFormatENS_5LevelE:
 1748|  68.2k|const base::LogFormat& TypedConfigurations::logFormat(Level level) {
 1749|  68.2k|  return getConfigByRef<base::LogFormat>(level, &m_logFormatMap, "logFormat");
 1750|  68.2k|}
_ZN2el4base19TypedConfigurations5buildEPNS_14ConfigurationsE:
 1776|  9.74k|void TypedConfigurations::build(Configurations* configurations) {
 1777|  9.74k|  base::threading::ScopedLock scopedLock(lock());
 1778|  9.74k|  auto getBool = [] (std::string boolStr) -> bool {  // Pass by value for trimming
 1779|  9.74k|    base::utils::Str::trim(boolStr);
 1780|  9.74k|    return (boolStr == "TRUE" || boolStr == "true" || boolStr == "1");
 1781|  9.74k|  };
 1782|  9.74k|  setValue(Level::Global, base::FileStreamPtr(NULL), &m_fileStreamMap);
 1783|  9.74k|  std::vector<Configuration*> withFileSizeLimit;
 1784|   711k|  for (Configurations::const_iterator it = configurations->begin(); it != configurations->end(); ++it) {
  ------------------
  |  Branch (1784:69): [True: 701k, False: 9.74k]
  ------------------
 1785|   701k|    Configuration* conf = *it;
 1786|       |    // We cannot use switch on strong enums because Intel C++ dont support them yet
 1787|   701k|    if (conf->configurationType() == ConfigurationType::Enabled) {
  ------------------
  |  Branch (1787:9): [True: 77.9k, False: 623k]
  ------------------
 1788|  77.9k|      setValue(conf->level(), getBool(conf->value()), &m_enabledMap);
 1789|   623k|    } else if (conf->configurationType() == ConfigurationType::ToFile) {
  ------------------
  |  Branch (1789:16): [True: 77.9k, False: 545k]
  ------------------
 1790|  77.9k|      setValue(conf->level(), getBool(conf->value()), &m_toFileMap);
 1791|   545k|    } else if (conf->configurationType() == ConfigurationType::ToStandardOutput) {
  ------------------
  |  Branch (1791:16): [True: 77.9k, False: 467k]
  ------------------
 1792|  77.9k|      setValue(conf->level(), getBool(conf->value()), &m_toStandardOutputMap);
 1793|   467k|    } else if (conf->configurationType() == ConfigurationType::Filename) {
  ------------------
  |  Branch (1793:16): [True: 77.9k, False: 389k]
  ------------------
 1794|       |      // We do not yet configure filename but we will configure in another
 1795|       |      // loop. This is because if file cannot be created, we will force ToFile
 1796|       |      // to be false. Because configuring logger is not necessarily performance
 1797|       |      // sensative operation, we can live with another loop; (by the way this loop
 1798|       |      // is not very heavy either)
 1799|   389k|    } else if (conf->configurationType() == ConfigurationType::Format) {
  ------------------
  |  Branch (1799:16): [True: 77.9k, False: 311k]
  ------------------
 1800|  77.9k|      setValue(conf->level(), base::LogFormat(conf->level(),
 1801|  77.9k|                                              base::type::string_t(conf->value().begin(), conf->value().end())), &m_logFormatMap);
 1802|   311k|    } else if (conf->configurationType() == ConfigurationType::SubsecondPrecision) {
  ------------------
  |  Branch (1802:16): [True: 77.9k, False: 233k]
  ------------------
 1803|  77.9k|      setValue(Level::Global,
 1804|  77.9k|               base::SubsecondPrecision(static_cast<int>(getULong(conf->value()))), &m_subsecondPrecisionMap);
 1805|   233k|    } else if (conf->configurationType() == ConfigurationType::PerformanceTracking) {
  ------------------
  |  Branch (1805:16): [True: 77.9k, False: 155k]
  ------------------
 1806|  77.9k|      setValue(Level::Global, getBool(conf->value()), &m_performanceTrackingMap);
 1807|   155k|    } else if (conf->configurationType() == ConfigurationType::MaxLogFileSize) {
  ------------------
  |  Branch (1807:16): [True: 77.9k, False: 77.9k]
  ------------------
 1808|  77.9k|      auto v = getULong(conf->value());
 1809|  77.9k|      setValue(conf->level(), static_cast<std::size_t>(v), &m_maxLogFileSizeMap);
 1810|  77.9k|      if (v != 0) {
  ------------------
  |  Branch (1810:11): [True: 0, False: 77.9k]
  ------------------
 1811|      0|        withFileSizeLimit.push_back(conf);
 1812|      0|      }
 1813|  77.9k|    } else if (conf->configurationType() == ConfigurationType::LogFlushThreshold) {
  ------------------
  |  Branch (1813:16): [True: 77.9k, False: 0]
  ------------------
 1814|  77.9k|      setValue(conf->level(), static_cast<std::size_t>(getULong(conf->value())), &m_logFlushThresholdMap);
 1815|  77.9k|    }
 1816|   701k|  }
 1817|       |  // As mentioned earlier, we will now set filename configuration in separate loop to deal with non-existent files
 1818|   711k|  for (Configurations::const_iterator it = configurations->begin(); it != configurations->end(); ++it) {
  ------------------
  |  Branch (1818:69): [True: 701k, False: 9.74k]
  ------------------
 1819|   701k|    Configuration* conf = *it;
 1820|   701k|    if (conf->configurationType() == ConfigurationType::Filename) {
  ------------------
  |  Branch (1820:9): [True: 77.9k, False: 623k]
  ------------------
 1821|  77.9k|      insertFile(conf->level(), conf->value());
 1822|  77.9k|    }
 1823|   701k|  }
 1824|  9.74k|  for (std::vector<Configuration*>::iterator conf = withFileSizeLimit.begin();
 1825|  9.74k|       conf != withFileSizeLimit.end(); ++conf) {
  ------------------
  |  Branch (1825:8): [True: 0, False: 9.74k]
  ------------------
 1826|       |    // This is not unsafe as mutex is locked in currect scope
 1827|      0|    unsafeValidateFileRolling((*conf)->level(), base::defaultPreRollOutCallback);
 1828|      0|  }
 1829|  9.74k|}
_ZN2el4base19TypedConfigurations8getULongENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
 1831|   233k|unsigned long TypedConfigurations::getULong(std::string confVal) {
 1832|   233k|  bool valid = true;
 1833|   233k|  base::utils::Str::trim(confVal);
 1834|   233k|  valid = !confVal.empty() && std::find_if(confVal.begin(), confVal.end(),
  ------------------
  |  Branch (1834:11): [True: 233k, False: 0]
  |  Branch (1834:31): [True: 233k, False: 0]
  ------------------
 1835|   233k|  [](char c) {
 1836|   233k|    return !base::utils::Str::isDigit(c);
 1837|   233k|  }) == confVal.end();
 1838|   233k|  if (!valid) {
  ------------------
  |  Branch (1838:7): [True: 0, False: 233k]
  ------------------
 1839|      0|    valid = false;
 1840|      0|    ELPP_ASSERT(valid, "Configuration value not a valid integer [" << confVal << "]");
  ------------------
  |  |  178|      0|#    define ELPP_ASSERT(expr, msg) if (!(expr)) { \
  |  |  ------------------
  |  |  |  Branch (178:40): [True: 0, False: 0]
  |  |  ------------------
  |  |  179|      0|std::stringstream internalInfoStream; internalInfoStream << msg; \
  |  |  ------------------
  |  |  |  |  160|      0|#  define ELPP_INTERNAL_DEBUGGING_OUT_ERROR std::cerr
  |  |  ------------------
  |  |  180|      0|ELPP_INTERNAL_DEBUGGING_OUT_ERROR\
  |  |  181|      0|<< "ASSERTION FAILURE FROM EASYLOGGING++ (LINE: " \
  |  |  182|      0|<< __LINE__ << ") [" #expr << "] WITH MESSAGE \"" << ELPP_INTERNAL_DEBUGGING_MSG(internalInfoStream.str()) << "\"" \
  |  |  ------------------
  |  |  |  |  166|      0|#  define ELPP_INTERNAL_DEBUGGING_MSG(msg) msg
  |  |  ------------------
  |  |  183|      0|<< ELPP_INTERNAL_DEBUGGING_ENDL; }
  |  |  ------------------
  |  |  |  |  163|      0|#  define ELPP_INTERNAL_DEBUGGING_ENDL std::endl
  |  |  ------------------
  ------------------
 1841|      0|    return 0;
 1842|      0|  }
 1843|   233k|  return atol(confVal.c_str());
 1844|   233k|}
_ZN2el4base19TypedConfigurations10insertFileENS_5LevelERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
 1885|  77.9k|void TypedConfigurations::insertFile(Level level, const std::string& fullFilename) {
 1886|  77.9k|  if (fullFilename.empty())
  ------------------
  |  Branch (1886:7): [True: 77.9k, False: 0]
  ------------------
 1887|  77.9k|    return;
 1888|      0|  std::string resolvedFilename = resolveFilename(fullFilename);
 1889|      0|  if (resolvedFilename.empty()) {
  ------------------
  |  Branch (1889:7): [True: 0, False: 0]
  ------------------
 1890|      0|    std::cerr << "Could not load empty file for logging, please re-check your configurations for level ["
 1891|      0|              << LevelHelper::convertToString(level) << "]";
 1892|      0|  }
 1893|      0|  std::string filePath = base::utils::File::extractPathFromFilename(resolvedFilename, base::consts::kFilePathSeperator);
 1894|      0|  if (filePath.size() < resolvedFilename.size()) {
  ------------------
  |  Branch (1894:7): [True: 0, False: 0]
  ------------------
 1895|      0|    base::utils::File::createPath(filePath);
 1896|      0|  }
 1897|      0|  auto create = [&](Level level) {
 1898|      0|    base::LogStreamsReferenceMap::iterator filestreamIter = m_logStreamsReference->find(resolvedFilename);
 1899|      0|    base::type::fstream_t* fs = nullptr;
 1900|      0|    if (filestreamIter == m_logStreamsReference->end()) {
 1901|       |      // We need a completely new stream, nothing to share with
 1902|      0|      fs = base::utils::File::newFileStream(resolvedFilename);
 1903|      0|      m_filenameMap.insert(std::make_pair(level, resolvedFilename));
 1904|      0|      m_fileStreamMap.insert(std::make_pair(level, base::FileStreamPtr(fs)));
 1905|      0|      m_logStreamsReference->insert(std::make_pair(resolvedFilename, base::FileStreamPtr(m_fileStreamMap.at(level))));
 1906|      0|    } else {
 1907|       |      // Woops! we have an existing one, share it!
 1908|      0|      m_filenameMap.insert(std::make_pair(level, filestreamIter->first));
 1909|      0|      m_fileStreamMap.insert(std::make_pair(level, base::FileStreamPtr(filestreamIter->second)));
 1910|      0|      fs = filestreamIter->second.get();
 1911|      0|    }
 1912|      0|    if (fs == nullptr) {
 1913|       |      // We display bad file error from newFileStream()
 1914|      0|      ELPP_INTERNAL_ERROR("Setting [TO_FILE] of ["
 1915|      0|                          << LevelHelper::convertToString(level) << "] to FALSE", false);
 1916|      0|      setValue(level, false, &m_toFileMap);
 1917|      0|    }
 1918|      0|  };
 1919|       |  // If we dont have file conf for any level, create it for Level::Global first
 1920|       |  // otherwise create for specified level
 1921|      0|  create(m_filenameMap.empty() && m_fileStreamMap.empty() ? Level::Global : level);
  ------------------
  |  Branch (1921:10): [True: 0, False: 0]
  |  Branch (1921:35): [True: 0, False: 0]
  ------------------
 1922|      0|}
_ZN2el4base17RegisteredLoggersC2ERKNSt3__110shared_ptrINS_10LogBuilderEEE:
 1991|  9.74k|  m_defaultLogBuilder(defaultLogBuilder) {
 1992|  9.74k|  m_defaultConfigurations.setToDefault();
 1993|  9.74k|}
_ZN2el4base17RegisteredLoggers3getERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEb:
 1995|  19.4k|Logger* RegisteredLoggers::get(const std::string& id, bool forceCreation) {
 1996|  19.4k|  base::threading::ScopedLock scopedLock(lock());
 1997|  19.4k|  Logger* logger_ = base::utils::Registry<Logger, std::string>::get(id);
 1998|  19.4k|  if (logger_ == nullptr && forceCreation) {
  ------------------
  |  Branch (1998:7): [True: 9.74k, False: 9.74k]
  |  Branch (1998:29): [True: 9.74k, False: 0]
  ------------------
 1999|  9.74k|    bool validId = Logger::isValidId(id);
 2000|  9.74k|    if (!validId) {
  ------------------
  |  Branch (2000:9): [True: 0, False: 9.74k]
  ------------------
 2001|      0|      ELPP_ASSERT(validId, "Invalid logger ID [" << id << "]. Not registering this logger.");
  ------------------
  |  |  178|      0|#    define ELPP_ASSERT(expr, msg) if (!(expr)) { \
  |  |  ------------------
  |  |  |  Branch (178:40): [True: 0, False: 0]
  |  |  ------------------
  |  |  179|      0|std::stringstream internalInfoStream; internalInfoStream << msg; \
  |  |  ------------------
  |  |  |  |  160|      0|#  define ELPP_INTERNAL_DEBUGGING_OUT_ERROR std::cerr
  |  |  ------------------
  |  |  180|      0|ELPP_INTERNAL_DEBUGGING_OUT_ERROR\
  |  |  181|      0|<< "ASSERTION FAILURE FROM EASYLOGGING++ (LINE: " \
  |  |  182|      0|<< __LINE__ << ") [" #expr << "] WITH MESSAGE \"" << ELPP_INTERNAL_DEBUGGING_MSG(internalInfoStream.str()) << "\"" \
  |  |  ------------------
  |  |  |  |  166|      0|#  define ELPP_INTERNAL_DEBUGGING_MSG(msg) msg
  |  |  ------------------
  |  |  183|      0|<< ELPP_INTERNAL_DEBUGGING_ENDL; }
  |  |  ------------------
  |  |  |  |  163|      0|#  define ELPP_INTERNAL_DEBUGGING_ENDL std::endl
  |  |  ------------------
  ------------------
 2002|      0|      return nullptr;
 2003|      0|    }
 2004|  9.74k|    logger_ = new Logger(id, m_defaultConfigurations, &m_logStreamsReference);
 2005|  9.74k|    logger_->m_logBuilder = m_defaultLogBuilder;
 2006|  9.74k|    registerNew(id, logger_);
 2007|  9.74k|    LoggerRegistrationCallback* callback = nullptr;
 2008|  9.74k|    for (const std::pair<std::string, base::type::LoggerRegistrationCallbackPtr>& h
 2009|  9.74k|         : m_loggerRegistrationCallbacks) {
  ------------------
  |  Branch (2009:10): [True: 0, False: 9.74k]
  ------------------
 2010|      0|      callback = h.second.get();
 2011|      0|      if (callback != nullptr && callback->enabled()) {
  ------------------
  |  Branch (2011:11): [True: 0, False: 0]
  |  Branch (2011:34): [True: 0, False: 0]
  ------------------
 2012|      0|        callback->handle(logger_);
 2013|      0|      }
 2014|      0|    }
 2015|  9.74k|  }
 2016|  19.4k|  return logger_;
 2017|  19.4k|}
_ZN2el4base17RegisteredLoggers14unsafeFlushAllEv:
 2032|  9.74k|void RegisteredLoggers::unsafeFlushAll(void) {
 2033|  9.74k|  ELPP_INTERNAL_INFO(1, "Flushing all log files");
 2034|  9.74k|  for (base::LogStreamsReferenceMap::iterator it = m_logStreamsReference.begin();
 2035|  9.74k|       it != m_logStreamsReference.end(); ++it) {
  ------------------
  |  Branch (2035:8): [True: 0, False: 9.74k]
  ------------------
 2036|      0|    if (it->second.get() == nullptr) continue;
  ------------------
  |  Branch (2036:9): [True: 0, False: 0]
  ------------------
 2037|      0|    it->second->flush();
 2038|      0|  }
 2039|  9.74k|}
_ZN2el4base9VRegistryC2EtPj:
 2043|  9.74k|VRegistry::VRegistry(base::type::VerboseLevel level, base::type::EnumType* pFlags) : m_level(level), m_pFlags(pFlags) {
 2044|  9.74k|}
_ZN2el4base9VRegistry7allowedENS_5LevelERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
 2219|  4.17k|bool VRegistry::allowed(Level level, const std::string &category) {
 2220|  4.17k|  return priority_allowed(priority(level), category);
 2221|  4.17k|}
_ZN2el4base9VRegistry16priority_allowedEiRKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
 2222|   132k|bool VRegistry::priority_allowed(const int pri, const std::string &category) {
 2223|   132k|  base::threading::ScopedLock scopedLock(lock());
 2224|   132k|  const std::map<std::string, int>::const_iterator it = m_cached_allowed_categories.find(category);
 2225|   132k|  if (it != m_cached_allowed_categories.end())
  ------------------
  |  Branch (2225:7): [True: 0, False: 132k]
  ------------------
 2226|      0|    return pri <= it->second;
 2227|   132k|  if (m_categories.empty()) {
  ------------------
  |  Branch (2227:7): [True: 132k, False: 0]
  ------------------
 2228|   132k|    return false;
 2229|   132k|  } else {
 2230|      0|    std::vector<std::pair<std::string, Level>>::const_reverse_iterator it = m_categories.rbegin();
 2231|      0|    for (; it != m_categories.rend(); ++it) {
  ------------------
  |  Branch (2231:12): [True: 0, False: 0]
  ------------------
 2232|      0|      if (base::utils::Str::wildCardMatch(category.c_str(), it->first.c_str())) {
  ------------------
  |  Branch (2232:11): [True: 0, False: 0]
  ------------------
 2233|      0|        const int p = priority(it->second);
 2234|      0|        m_cached_allowed_categories.insert(std::make_pair(category, p));
 2235|      0|        return pri <= p;
 2236|      0|      }
 2237|      0|    }
 2238|      0|    m_cached_allowed_categories.insert(std::make_pair(category, -1));
 2239|      0|    return false;
 2240|      0|  }
 2241|   132k|}
_ZN2el4base7Storage7getELPPEv:
 2283|   132k|{
 2284|   132k|  if (!el::base::elStorage)
  ------------------
  |  Branch (2284:7): [True: 9.74k, False: 122k]
  ------------------
 2285|  9.74k|    el::base::elStorage = new el::base::Storage(el::LogBuilderPtr(new el::base::DefaultLogBuilder()));
 2286|   132k|  return el::base::elStorage;
 2287|   132k|}
_ZN2el4base7StorageC2ERKNSt3__110shared_ptrINS_10LogBuilderEEE:
 2294|  9.74k|  m_registeredHitCounters(new base::RegisteredHitCounters()),
 2295|  9.74k|  m_registeredLoggers(new base::RegisteredLoggers(defaultLogBuilder)),
 2296|  9.74k|  m_flags(ELPP_DEFAULT_LOGGING_FLAGS),
  ------------------
  |  | 2279|  9.74k|#   define ELPP_DEFAULT_LOGGING_FLAGS 0x0
  ------------------
 2297|  9.74k|  m_vRegistry(new base::VRegistry(0, &m_flags)),
 2298|       |
 2299|       |#if ELPP_ASYNC_LOGGING
 2300|       |  m_asyncLogQueue(new base::AsyncLogQueue()),
 2301|       |  m_asyncDispatchWorker(asyncDispatchWorker),
 2302|       |#endif  // ELPP_ASYNC_LOGGING
 2303|       |
 2304|  9.74k|  m_preRollOutCallback(base::defaultPreRollOutCallback) {
 2305|       |  // Register default logger
 2306|  9.74k|  m_registeredLoggers->get(std::string(base::consts::kDefaultLoggerId));
 2307|       |  // We register default logger anyway (worse case it's not going to register) just in case
 2308|  9.74k|  m_registeredLoggers->get("default");
 2309|       |
 2310|       |#if defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_PERFORMANCE_TRACKING)
 2311|       |  // Register performance logger and reconfigure format
 2312|       |  Logger* performanceLogger = m_registeredLoggers->get(std::string(base::consts::kPerformanceLoggerId));
 2313|       |  m_registeredLoggers->get("performance");
 2314|       |  performanceLogger->configurations()->setGlobally(ConfigurationType::Format, std::string("%datetime %level %msg"));
 2315|       |  performanceLogger->reconfigure();
 2316|       |#endif // defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_PERFORMANCE_TRACKING)
 2317|       |
 2318|       |#if defined(ELPP_SYSLOG)
 2319|       |  // Register syslog logger and reconfigure format
 2320|       |  Logger* sysLogLogger = m_registeredLoggers->get(std::string(base::consts::kSysLogLoggerId));
 2321|       |  sysLogLogger->configurations()->setGlobally(ConfigurationType::Format, std::string("%level: %msg"));
 2322|       |  sysLogLogger->reconfigure();
 2323|       |#endif //  defined(ELPP_SYSLOG)
 2324|  9.74k|  addFlag(LoggingFlag::AllowVerboseIfModuleNotSpecified);
 2325|  9.74k|  addFlag(LoggingFlag::CreateLoggerAutomatically);
 2326|       |#if ELPP_ASYNC_LOGGING
 2327|       |  installLogDispatchCallback<base::AsyncLogDispatchCallback>(std::string("AsyncLogDispatchCallback"));
 2328|       |#else
 2329|  9.74k|  installLogDispatchCallback<base::DefaultLogDispatchCallback>(std::string("DefaultLogDispatchCallback"));
 2330|  9.74k|#endif  // ELPP_ASYNC_LOGGING
 2331|       |#if defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_PERFORMANCE_TRACKING)
 2332|       |  installPerformanceTrackingCallback<base::DefaultPerformanceTrackingCallback>
 2333|       |  (std::string("DefaultPerformanceTrackingCallback"));
 2334|       |#endif // defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_PERFORMANCE_TRACKING)
 2335|  9.74k|  ELPP_INTERNAL_INFO(1, "Easylogging++ has been initialized");
 2336|       |#if ELPP_ASYNC_LOGGING
 2337|       |  m_asyncDispatchWorker->start();
 2338|       |#endif  // ELPP_ASYNC_LOGGING
 2339|  9.74k|}
_ZN2el4base7StorageD2Ev:
 2341|  9.74k|Storage::~Storage(void) {
 2342|  9.74k|  ELPP_INTERNAL_INFO(4, "Destroying storage");
 2343|       |#if ELPP_ASYNC_LOGGING
 2344|       |  ELPP_INTERNAL_INFO(5, "Replacing log dispatch callback to synchronous");
 2345|       |  uninstallLogDispatchCallback<base::AsyncLogDispatchCallback>(std::string("AsyncLogDispatchCallback"));
 2346|       |  installLogDispatchCallback<base::DefaultLogDispatchCallback>(std::string("DefaultLogDispatchCallback"));
 2347|       |  ELPP_INTERNAL_INFO(5, "Destroying asyncDispatchWorker");
 2348|       |  base::utils::safeDelete(m_asyncDispatchWorker);
 2349|       |  ELPP_INTERNAL_INFO(5, "Destroying asyncLogQueue");
 2350|       |  base::utils::safeDelete(m_asyncLogQueue);
 2351|       |#endif  // ELPP_ASYNC_LOGGING
 2352|  9.74k|  ELPP_INTERNAL_INFO(5, "Destroying registeredHitCounters");
 2353|  9.74k|  base::utils::safeDelete(m_registeredHitCounters);
 2354|  9.74k|  ELPP_INTERNAL_INFO(5, "Destroying registeredLoggers");
 2355|  9.74k|  base::utils::safeDelete(m_registeredLoggers);
 2356|  9.74k|  ELPP_INTERNAL_INFO(5, "Destroying vRegistry");
 2357|  9.74k|  base::utils::safeDelete(m_vRegistry);
 2358|  9.74k|}
_ZN2el7Loggers7allowedENS_5LevelEPKc:
 3361|   128k|{
 3362|   128k|  const int pri = base::priority(level);
 3363|   128k|  if (pri > base::s_lowest_priority)
  ------------------
  |  Branch (3363:7): [True: 0, False: 128k]
  ------------------
 3364|      0|    return false;
 3365|   128k|  return ELPP->vRegistry()->priority_allowed(pri, std::string{cat});
  ------------------
  |  | 2792|   128k|#define ELPP el::base::Storage::getELPP()
  ------------------
 3366|   128k|}
easylogging++.cc:_ZZN2el4base9LogFormat15parseFromFormatERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEENK3$_0clEPKcNS0_11FormatFlagsE:
 1597|  1.09M|  auto conditionalAddFlag = [&](const base::type::char_t* specifier, base::FormatFlags flag) {
 1598|  1.09M|    std::size_t foundAt = base::type::string_t::npos;
 1599|  1.39M|    while ((foundAt = formatCopy.find(specifier, foundAt + 1)) != base::type::string_t::npos) {
  ------------------
  |  Branch (1599:12): [True: 302k, False: 1.09M]
  ------------------
 1600|   302k|      if (foundAt > 0 && formatCopy[foundAt - 1] == base::consts::kFormatSpecifierChar) {
  ------------------
  |  Branch (1600:11): [True: 302k, False: 0]
  |  Branch (1600:26): [True: 0, False: 302k]
  ------------------
 1601|      0|        if (hasFlag(flag)) {
  ------------------
  |  Branch (1601:13): [True: 0, False: 0]
  ------------------
 1602|       |          // If we already have flag we remove the escape chars so that '%%' is turned to '%'
 1603|       |          // even after specifier resolution - this is because we only replaceFirst specifier
 1604|      0|          formatCopy.erase(foundAt - 1, 1);
 1605|      0|          ++foundAt;
 1606|      0|        }
 1607|   302k|      } else {
 1608|   302k|        if (!hasFlag(flag)) addFlag(flag);
  ------------------
  |  Branch (1608:13): [True: 302k, False: 0]
  ------------------
 1609|   302k|      }
 1610|   302k|    }
 1611|  1.09M|  };
easylogging++.cc:_ZZN2el4base19TypedConfigurations5buildEPNS_14ConfigurationsEENK3$_0clENSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE:
 1778|   311k|  auto getBool = [] (std::string boolStr) -> bool {  // Pass by value for trimming
 1779|   311k|    base::utils::Str::trim(boolStr);
 1780|   311k|    return (boolStr == "TRUE" || boolStr == "true" || boolStr == "1");
  ------------------
  |  Branch (1780:13): [True: 0, False: 311k]
  |  Branch (1780:34): [True: 311k, False: 0]
  |  Branch (1780:55): [True: 0, False: 0]
  ------------------
 1781|   311k|  };
easylogging++.cc:_ZN2el4baseL8priorityENS_5LevelE:
 2128|   132k|static int priority(Level level) {
 2129|   132k|  if (level == Level::Fatal) return 0;
  ------------------
  |  Branch (2129:7): [True: 0, False: 132k]
  ------------------
 2130|   132k|  if (level == Level::Error) return 1;
  ------------------
  |  Branch (2130:7): [True: 42.2k, False: 90.4k]
  ------------------
 2131|  90.4k|  if (level == Level::Warning) return 2;
  ------------------
  |  Branch (2131:7): [True: 77.1k, False: 13.3k]
  ------------------
 2132|  13.3k|  if (level == Level::Info) return 3;
  ------------------
  |  Branch (2132:7): [True: 6.22k, False: 7.08k]
  ------------------
 2133|  7.08k|  if (level == Level::Debug) return 4;
  ------------------
  |  Branch (2133:7): [True: 1.48k, False: 5.59k]
  ------------------
 2134|  5.59k|  if (level == Level::Verbose) return 5;
  ------------------
  |  Branch (2134:7): [True: 0, False: 5.59k]
  ------------------
 2135|  5.59k|  if (level == Level::Trace) return 6;
  ------------------
  |  Branch (2135:7): [True: 5.59k, False: 0]
  ------------------
 2136|      0|  return 7;
 2137|  5.59k|}
_ZN2el4base10EnsureELPPC2Ev:
 2288|      2|static struct EnsureELPP { EnsureELPP() { el::base::Storage::getELPP(); } } ensureELPP;
easylogging++.cc:_ZZN2el14Configurations11setGloballyENS_17ConfigurationTypeERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEbENK3$_0clEv:
  642|   613k|  LevelHelper::forEachLevel(&lIndex, [&](void) -> bool {
  643|   613k|    set(LevelHelper::castFromInt(lIndex), configurationType, value);
  644|   613k|    return false;  // Do not break lambda function yet as we need to set all levels regardless
  645|   613k|  });
easylogging++.cc:_ZZN2el14Configurations17unsafeSetGloballyENS_17ConfigurationTypeERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEbENK3$_0clEv:
  654|  2.45M|  LevelHelper::forEachLevel(&lIndex, [&](void) -> bool  {
  655|  2.45M|    unsafeSet(LevelHelper::castFromInt(lIndex), configurationType, value);
  656|  2.45M|    return false;  // Do not break lambda function yet as we need to set all levels regardless
  657|  2.45M|  });
easylogging++.cc:_ZZN2el6Logger18initUnflushedCountEvENK3$_0clEv:
  805|   136k|  LevelHelper::forEachLevel(&lIndex, [&](void) -> bool {
  806|   136k|    m_unflushedCount.insert(std::make_pair(LevelHelper::castFromInt(lIndex), 0));
  807|   136k|    return false;
  808|   136k|  });
easylogging++.cc:_ZZNK2el6Logger23resolveLoggerFormatSpecEvENK3$_0clEv:
  813|  68.2k|  LevelHelper::forEachLevel(&lIndex, [&](void) -> bool {
  814|  68.2k|    base::LogFormat* logFormat =
  815|  68.2k|    const_cast<base::LogFormat*>(&m_typedConfigurations->logFormat(LevelHelper::castFromInt(lIndex)));
  816|  68.2k|    base::utils::Str::replaceFirstWithEscape(logFormat->m_format, base::consts::kLoggerIdFormatSpecifier, m_id);
  817|  68.2k|    return false;
  818|  68.2k|  });
easylogging++.cc:_ZZN2el4base5utils3Str5ltrimERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEENK3$_0clEc:
  989|   545k|  str.erase(str.begin(), std::find_if(str.begin(), str.end(), [](char c) {
  990|   545k|    return !std::isspace(c);
  991|   545k|  } ));
easylogging++.cc:_ZZN2el4base5utils3Str5rtrimERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEENK3$_0clEc:
  996|   545k|  str.erase(std::find_if(str.rbegin(), str.rend(), [](char c) {
  997|   545k|    return !std::isspace(c);
  998|   545k|  }).base(), str.end());
easylogging++.cc:_ZZN2el4base19TypedConfigurations8getULongENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEENK3$_0clEc:
 1835|   233k|  [](char c) {
 1836|   233k|    return !base::utils::Str::isDigit(c);
 1837|   233k|  }) == confVal.end();

_ZN2el4base6NoCopyC2Ev:
  571|  29.2k|  NoCopy(void) {}
_ZNKSt3__14hashIN2el5LevelEEclERKS2_:
  624|   974k|  std::size_t operator()(const el::Level& l) const {
  625|   974k|    return hash<el::base::type::EnumType> {}(static_cast<el::base::type::EnumType>(l));
  626|   974k|  }
_ZN2el11LevelHelper11castFromIntEj:
  642|  3.27M|  static Level castFromInt(base::type::EnumType l) {
  643|  3.27M|    return static_cast<Level>(l);
  644|  3.27M|  }
_ZN2el4base18SubsecondPrecisionC2Ei:
  870|  77.9k|  explicit SubsecondPrecision(int width) {
  871|  77.9k|    init(width);
  872|  77.9k|  }
_ZN2el4base18SubsecondPrecisioneqERKS1_:
  873|  68.2k|  bool operator==(const SubsecondPrecision& ssPrec) {
  874|  68.2k|    return m_width == ssPrec.m_width && m_offset == ssPrec.m_offset;
  ------------------
  |  Branch (874:12): [True: 68.2k, False: 0]
  |  Branch (874:41): [True: 68.2k, False: 0]
  ------------------
  875|  68.2k|  }
_ZN2el4base9threading10ThreadSafe4lockEv:
 1037|  1.70M|  virtual inline base::threading::Mutex& lock(void) ELPP_FINAL { return m_mutex; }
_ZN2el4base9threading10ThreadSafeC2Ev:
 1039|  87.7k|  ThreadSafe(void) {}
_ZN2el4base9threading10ThreadSafeD2Ev:
 1040|  87.6k|  virtual ~ThreadSafe(void) {}
_ZN2el4base5utils3Str7isDigitEc:
 1107|   233k|  static inline bool isDigit(char c) {
 1108|   233k|    return c >= '0' && c <= '9';
  ------------------
  |  Branch (1108:12): [True: 233k, False: 0]
  |  Branch (1108:24): [True: 233k, False: 0]
  ------------------
 1109|   233k|  }
_ZN2el4base5utils15CommandLineArgsC2Ev:
 1251|  9.74k|  CommandLineArgs(void) {
 1252|  9.74k|    setArgs(0, static_cast<char**>(nullptr));
 1253|  9.74k|  }
_ZN2el4base5utils15CommandLineArgsD2Ev:
 1260|  9.74k|  virtual ~CommandLineArgs(void) {}
_ZN2el8LoggableD2Ev:
 1603|  1.64M|  virtual ~Loggable(void) {}
_ZN2el4base9LogFormatD2Ev:
 1620|   233k|  virtual ~LogFormat(void) {}
_ZNK2el4base9LogFormat7hasFlagENS0_11FormatFlagsE:
 1647|   613k|  inline bool hasFlag(base::FormatFlags flag) const {
 1648|   613k|    return base::utils::hasFlag(flag, m_flags);
 1649|   613k|  }
_ZN2el4base9LogFormat7addFlagENS0_11FormatFlagsE:
 1664|   380k|  inline void addFlag(base::FormatFlags flag) {
 1665|   380k|    base::utils::addFlag(flag, &m_flags);
 1666|   380k|  }
_ZN2el13ConfigurationD2Ev:
 1716|  1.40M|  virtual ~Configuration(void) {
 1717|  1.40M|  }
_ZNK2el13Configuration5levelEv:
 1723|   145M|  inline Level level(void) const {
 1724|   145M|    return m_level;
 1725|   145M|  }
_ZNK2el13Configuration17configurationTypeEv:
 1728|  23.2M|  inline ConfigurationType configurationType(void) const {
 1729|  23.2M|    return m_configurationType;
 1730|  23.2M|  }
_ZNK2el13Configuration5valueEv:
 1733|  1.48M|  inline const std::string& value(void) const {
 1734|  1.48M|    return m_value;
 1735|  1.48M|  }
_ZN2el13Configuration8setValueERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 1740|  2.50M|  inline void setValue(const std::string& value) {
 1741|  2.50M|    m_value = value;
 1742|  2.50M|  }
_ZN2el14ConfigurationsD2Ev:
 1781|  19.4k|  virtual ~Configurations(void) {
 1782|  19.4k|  }
_ZN2el4base19TypedConfigurationsD2Ev:
 1950|  9.74k|  virtual ~TypedConfigurations(void) {
 1951|  9.74k|  }
_ZN2el10LogBuilderC2Ev:
 2237|  9.74k|  LogBuilder() : m_termSupportsColor(base::utils::OS::termSupportsColor()) {}
_ZN2el10LogBuilderD2Ev:
 2238|  9.74k|  virtual ~LogBuilder(void) {
 2239|  9.74k|    ELPP_INTERNAL_INFO(3, "Destroying log builder...")
 2240|  9.74k|  }
_ZN2el6LoggerD2Ev:
 2259|  9.74k|  virtual ~Logger(void) {
 2260|  9.74k|    base::utils::safeDelete(m_typedConfigurations);
 2261|  9.74k|  }
_ZN2el4base17RegisteredLoggersD2Ev:
 2390|  9.74k|  virtual ~RegisteredLoggers(void) {
 2391|  9.74k|    unsafeFlushAll();
 2392|  9.74k|  }
_ZNK2el4base7Storage9vRegistryEv:
 2645|   132k|  inline base::VRegistry* vRegistry(void) const {
 2646|   132k|    return m_vRegistry;
 2647|   132k|  }
_ZN2el4base7Storage7addFlagENS_11LoggingFlagE:
 2659|  19.4k|  inline void addFlag(LoggingFlag flag) {
 2660|  19.4k|    base::utils::addFlag(flag, &m_flags);
 2661|  19.4k|  }
_ZN2el4base5utils16RegistryWithPredINS_13ConfigurationENS3_9PredicateEE3getINS_5LevelENS_17ConfigurationTypeEEEPS3_RKT_T0_:
 1554|  3.90M|  T_Ptr* get(const T& arg1, const T2 arg2) {
 1555|  3.90M|    iterator iter = std::find_if(this->list().begin(), this->list().end(), Pred(arg1, arg2));
 1556|  3.90M|    if (iter != this->list().end() && *iter != nullptr) {
  ------------------
  |  Branch (1556:9): [True: 2.50M, False: 1.40M]
  |  Branch (1556:9): [True: 2.50M, False: 1.40M]
  |  Branch (1556:39): [True: 2.50M, False: 0]
  ------------------
 1557|  2.50M|      return *iter;
 1558|  2.50M|    }
 1559|  1.40M|    return nullptr;
 1560|  3.90M|  }
_ZN2el4base5utils16RegistryWithPredINS_13ConfigurationENS3_9PredicateEE13unregisterAllEv:
 1523|  19.4k|  virtual void unregisterAll(void) ELPP_FINAL {
 1524|  19.4k|    if (!this->empty()) {
  ------------------
  |  Branch (1524:9): [True: 19.4k, False: 0]
  ------------------
 1525|  1.40M|      for (auto&& curr : this->list()) {
  ------------------
  |  Branch (1525:24): [True: 1.40M, False: 19.4k]
  ------------------
 1526|  1.40M|        base::utils::safeDelete(curr);
 1527|  1.40M|      }
 1528|  19.4k|      this->list().clear();
 1529|  19.4k|    }
 1530|  19.4k|  }
_ZN2el4base5utils8RegistryINS_6LoggerENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEE10unregisterERKSA_:
 1455|  9.74k|  void unregister(const T_Key& uniqKey) {
 1456|  9.74k|    T_Ptr* existing = get(uniqKey);
 1457|  9.74k|    if (existing != nullptr) {
  ------------------
  |  Branch (1457:9): [True: 0, False: 9.74k]
  ------------------
 1458|      0|      this->list().erase(uniqKey);
 1459|      0|      base::utils::safeDelete(existing);
 1460|      0|    }
 1461|  9.74k|  }
_ZN2el4base5utils8RegistryINS_6LoggerENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEE3getERKSA_:
 1464|  29.2k|  T_Ptr* get(const T_Key& uniqKey) {
 1465|  29.2k|    iterator it = this->list().find(uniqKey);
 1466|  29.2k|    return it == this->list().end()
  ------------------
  |  Branch (1466:12): [True: 19.4k, False: 9.74k]
  ------------------
 1467|  29.2k|           ? nullptr
 1468|  29.2k|           : it->second;
 1469|  29.2k|  }
_ZN2el4base5utils16AbstractRegistryINS_13ConfigurationENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEE5beginEv:
 1348|  19.4k|  virtual inline iterator begin(void) ELPP_FINAL {
 1349|  19.4k|    return m_list.begin();
 1350|  19.4k|  }
_ZN2el4base5utils16AbstractRegistryINS_13ConfigurationENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEE3endEv:
 1353|  1.42M|  virtual inline iterator end(void) ELPP_FINAL {
 1354|  1.42M|    return m_list.end();
 1355|  1.42M|  }
_ZNK2el4base5utils16AbstractRegistryINS_13ConfigurationENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEE5emptyEv:
 1369|  19.4k|  virtual inline bool empty(void) const ELPP_FINAL {
 1370|  19.4k|    return m_list.empty();
 1371|  19.4k|  }
_ZNK2el4base5utils16AbstractRegistryINS_13ConfigurationENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEE4sizeEv:
 1374|  19.4k|  virtual inline std::size_t size(void) const ELPP_FINAL {
 1375|  19.4k|    return m_list.size();
 1376|  19.4k|  }
_ZN2el4base5utils16AbstractRegistryINS_13ConfigurationENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEE4listEv:
 1379|  13.1M|  virtual inline Container& list(void) ELPP_FINAL {
 1380|  13.1M|    return m_list;
 1381|  13.1M|  }
_ZN2el4base5utils16RegistryWithPredINS_13ConfigurationENS3_9PredicateEE11registerNewEPS3_:
 1547|  1.40M|  virtual inline void registerNew(T_Ptr* ptr) ELPP_FINAL {
 1548|  1.40M|    this->list().push_back(ptr);
 1549|  1.40M|  }
_ZNK2el4base5utils16AbstractRegistryINS_6LoggerENSt3__113unordered_mapINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEPS3_NS4_4hashISB_EENS4_8equal_toISB_EENS9_INS4_4pairIKSB_SC_EEEEEEE5emptyEv:
 1369|  9.74k|  virtual inline bool empty(void) const ELPP_FINAL {
 1370|  9.74k|    return m_list.empty();
 1371|  9.74k|  }
_ZN2el4base5utils16AbstractRegistryINS_6LoggerENSt3__113unordered_mapINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEPS3_NS4_4hashISB_EENS4_8equal_toISB_EENS9_INS4_4pairIKSB_SC_EEEEEEE4listEv:
 1379|  87.7k|  virtual inline Container& list(void) ELPP_FINAL {
 1380|  87.7k|    return m_list;
 1381|  87.7k|  }
_ZN2el4base5utils8RegistryINS_6LoggerENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEE13unregisterAllEv:
 1439|  9.74k|  virtual void unregisterAll(void) ELPP_FINAL {
 1440|  9.74k|    if (!this->empty()) {
  ------------------
  |  Branch (1440:9): [True: 9.74k, False: 0]
  ------------------
 1441|  9.74k|      for (auto&& curr : this->list()) {
  ------------------
  |  Branch (1441:24): [True: 9.74k, False: 9.74k]
  ------------------
 1442|  9.74k|        base::utils::safeDelete(curr.second);
 1443|  9.74k|      }
 1444|  9.74k|      this->list().clear();
 1445|  9.74k|    }
 1446|  9.74k|  }
_ZN2el4base5utils8RegistryINS_6LoggerENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEE11registerNewERKSA_PS3_:
 1449|  9.74k|  virtual void registerNew(const T_Key& uniqKey, T_Ptr* ptr) ELPP_FINAL {
 1450|  9.74k|    unregister(uniqKey);
 1451|  9.74k|    this->list().insert(std::make_pair(uniqKey, ptr));
 1452|  9.74k|  }
_ZN2el4base5utils16RegistryWithPredINS_13ConfigurationENS3_9PredicateEED2Ev:
 1492|  19.4k|  virtual ~RegistryWithPred(void) {
 1493|  19.4k|    unregisterAll();
 1494|  19.4k|  }
_ZN2el4base5utils16AbstractRegistryINS_13ConfigurationENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEED2Ev:
 1344|  19.4k|  virtual ~AbstractRegistry(void) {
 1345|  19.4k|  }
mlog.cpp:_ZN2el4base5utilsL10safeDeleteINS_13ConfigurationEEENSt3__19enable_ifIXsr3std10is_pointerIPT_EE5valueEvE4typeERS7_:
  889|  1.40M|safeDelete(T*& pointer) {
  890|  1.40M|  if (pointer == nullptr)
  ------------------
  |  Branch (890:7): [True: 0, False: 1.40M]
  ------------------
  891|      0|    return;
  892|  1.40M|  delete pointer;
  893|  1.40M|  pointer = nullptr;
  894|  1.40M|}
easylogging++.cc:_ZN2el4base5utilsL7addFlagINS0_11FormatFlagsEEEvT_Pj:
  912|   380k|static inline void addFlag(Enum e, base::type::EnumType* flag) {
  913|   380k|  *flag = base::utils::bitwise::Or<Enum>(e, *flag);
  914|   380k|}
easylogging++.cc:_ZN2el4base5utils7bitwiseL2OrINS0_11FormatFlagsEEEjT_j:
  907|   380k|static inline base::type::EnumType Or(Enum e, base::type::EnumType flag) {
  908|   380k|  return static_cast<base::type::EnumType>(flag) | static_cast<base::type::EnumType>(e);
  909|   380k|}
easylogging++.cc:_ZN2el4base5utilsL7hasFlagINS0_11FormatFlagsEEEbT_j:
  920|   613k|static inline bool hasFlag(Enum e, base::type::EnumType flag) {
  921|   613k|  return base::utils::bitwise::And<Enum>(e, flag) > 0x0;
  922|   613k|}
easylogging++.cc:_ZN2el4base5utils7bitwiseL3AndINS0_11FormatFlagsEEEjT_j:
  899|   613k|static inline base::type::EnumType And(Enum e, base::type::EnumType flag) {
  900|   613k|  return static_cast<base::type::EnumType>(flag) & static_cast<base::type::EnumType>(e);
  901|   613k|}
easylogging++.cc:_ZN2el4base5utilsL10safeDeleteINS_6LoggerEEENSt3__19enable_ifIXsr3std10is_pointerIPT_EE5valueEvE4typeERS7_:
  889|  9.74k|safeDelete(T*& pointer) {
  890|  9.74k|  if (pointer == nullptr)
  ------------------
  |  Branch (890:7): [True: 0, False: 9.74k]
  ------------------
  891|      0|    return;
  892|  9.74k|  delete pointer;
  893|  9.74k|  pointer = nullptr;
  894|  9.74k|}
_ZN2el4base5utils16RegistryWithPredINS0_10HitCounterENS3_9PredicateEEC2Ev:
 1489|  9.74k|  RegistryWithPred(void) {
 1490|  9.74k|  }
_ZN2el4base5utils16AbstractRegistryINS0_10HitCounterENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEEC2Ev:
 1299|  9.74k|  AbstractRegistry(void) {}
_ZN2el4base5utils16AbstractRegistryINS0_10HitCounterENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEED2Ev:
 1344|  9.74k|  virtual ~AbstractRegistry(void) {
 1345|  9.74k|  }
_ZN2el4base5utils16RegistryWithPredINS0_10HitCounterENS3_9PredicateEED2Ev:
 1492|  9.74k|  virtual ~RegistryWithPred(void) {
 1493|  9.74k|    unregisterAll();
 1494|  9.74k|  }
_ZNK2el4base5utils16AbstractRegistryINS0_10HitCounterENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEE5emptyEv:
 1369|  9.74k|  virtual inline bool empty(void) const ELPP_FINAL {
 1370|  9.74k|    return m_list.empty();
 1371|  9.74k|  }
_ZN2el4base5utils16RegistryWithPredINS0_10HitCounterENS3_9PredicateEE13unregisterAllEv:
 1523|  9.74k|  virtual void unregisterAll(void) ELPP_FINAL {
 1524|  9.74k|    if (!this->empty()) {
  ------------------
  |  Branch (1524:9): [True: 0, False: 9.74k]
  ------------------
 1525|      0|      for (auto&& curr : this->list()) {
  ------------------
  |  Branch (1525:24): [True: 0, False: 0]
  ------------------
 1526|      0|        base::utils::safeDelete(curr);
 1527|      0|      }
 1528|      0|      this->list().clear();
 1529|      0|    }
 1530|  9.74k|  }
easylogging++.cc:_ZN2el4base5utilsL7addFlagINS_11LoggingFlagEEEvT_Pj:
  912|  19.4k|static inline void addFlag(Enum e, base::type::EnumType* flag) {
  913|  19.4k|  *flag = base::utils::bitwise::Or<Enum>(e, *flag);
  914|  19.4k|}
easylogging++.cc:_ZN2el4base5utils7bitwiseL2OrINS_11LoggingFlagEEEjT_j:
  907|  19.4k|static inline base::type::EnumType Or(Enum e, base::type::EnumType flag) {
  908|  19.4k|  return static_cast<base::type::EnumType>(flag) | static_cast<base::type::EnumType>(e);
  909|  19.4k|}
easylogging++.cc:_ZN2el4base5utilsL10safeDeleteINS0_19TypedConfigurationsEEENSt3__19enable_ifIXsr3std10is_pointerIPT_EE5valueEvE4typeERS7_:
  889|  19.4k|safeDelete(T*& pointer) {
  890|  19.4k|  if (pointer == nullptr)
  ------------------
  |  Branch (890:7): [True: 9.74k, False: 9.74k]
  ------------------
  891|  9.74k|    return;
  892|  9.74k|  delete pointer;
  893|  9.74k|  pointer = nullptr;
  894|  9.74k|}
_ZN2el4base5utils8RegistryINS_6LoggerENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEED2Ev:
 1434|  9.74k|  virtual ~Registry(void) {
 1435|  9.74k|    unregisterAll();
 1436|  9.74k|  }
_ZN2el4base5utils16AbstractRegistryINS_6LoggerENSt3__113unordered_mapINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEPS3_NS4_4hashISB_EENS4_8equal_toISB_EENS9_INS4_4pairIKSB_SC_EEEEEEED2Ev:
 1344|  9.74k|  virtual ~AbstractRegistry(void) {
 1345|  9.74k|  }
_ZN2el4base5utils16RegistryWithPredINS_13ConfigurationENS3_9PredicateEEC2Ev:
 1489|  19.4k|  RegistryWithPred(void) {
 1490|  19.4k|  }
_ZN2el4base5utils16AbstractRegistryINS_13ConfigurationENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEEC2Ev:
 1299|  19.4k|  AbstractRegistry(void) {}
_ZN2el4base5utils16AbstractRegistryINS_13ConfigurationENSt3__16vectorIPS3_NS4_9allocatorIS6_EEEEEneERKSA_:
 1322|  9.74k|  bool operator!=(const AbstractRegistry<T_Ptr, Container>& other) {
 1323|  9.74k|    if (size() != other.size()) {
  ------------------
  |  Branch (1323:9): [True: 9.74k, False: 0]
  ------------------
 1324|  9.74k|      return true;
 1325|  9.74k|    }
 1326|      0|    for (std::size_t i = 0; i < m_list.size(); ++i) {
  ------------------
  |  Branch (1326:29): [True: 0, False: 0]
  ------------------
 1327|      0|      if (m_list.at(i) != other.m_list.at(i)) {
  ------------------
  |  Branch (1327:11): [True: 0, False: 0]
  ------------------
 1328|      0|        return true;
 1329|      0|      }
 1330|      0|    }
 1331|      0|    return false;
 1332|      0|  }
_ZN2el4base19TypedConfigurations14getConfigByRefINS0_9LogFormatEEERT_NS_5LevelEPNSt3__113unordered_mapIS6_S4_NS7_4hashIS6_EENS7_8equal_toIS6_EENS7_9allocatorINS7_4pairIKS6_S4_EEEEEEPKc:
 1996|  68.2k|  inline Conf_T& getConfigByRef(Level level, std::unordered_map<Level, Conf_T>* confMap, const char* confName) {
 1997|  68.2k|    base::threading::ScopedLock scopedLock(lock());
 1998|  68.2k|    return unsafeGetConfigByRef(level, confMap, confName);  // This is not unsafe anymore - mutex locked in scope
 1999|  68.2k|  }
_ZN2el4base19TypedConfigurations20unsafeGetConfigByRefINS0_9LogFormatEEERT_NS_5LevelEPNSt3__113unordered_mapIS6_S4_NS7_4hashIS6_EENS7_8equal_toIS6_EENS7_9allocatorINS7_4pairIKS6_S4_EEEEEEPKc:
 2019|  68.2k|  Conf_T& unsafeGetConfigByRef(Level level, std::unordered_map<Level, Conf_T>* confMap, const char* confName) {
 2020|  68.2k|    ELPP_UNUSED(confName);
  ------------------
  |  |  240|  68.2k|#define ELPP_UNUSED(x) (void)x
  ------------------
 2021|  68.2k|    typename std::unordered_map<Level, Conf_T>::iterator it = confMap->find(level);
 2022|  68.2k|    if (it == confMap->end()) {
  ------------------
  |  Branch (2022:9): [True: 0, False: 68.2k]
  ------------------
 2023|      0|      try {
 2024|      0|        return confMap->at(Level::Global);
 2025|      0|      } catch (...) {
 2026|      0|        ELPP_INTERNAL_ERROR("Unable to get configuration [" << confName << "] for level ["
 2027|      0|                            << LevelHelper::convertToString(level) << "]"
 2028|      0|                            << std::endl << "Please ensure you have properly configured logger.", false);
 2029|      0|        throw; // The exception has to be rethrown, to abort a branch leading to UB.
 2030|      0|      }
 2031|      0|    }
 2032|  68.2k|    return it->second;
 2033|  68.2k|  }
_ZN2el4base19TypedConfigurations8setValueINSt3__110shared_ptrINS3_13basic_fstreamIcNS3_11char_traitsIcEEEEEEEEvNS_5LevelERKT_PNS3_13unordered_mapISA_SB_NS3_4hashISA_EENS3_8equal_toISA_EENS3_9allocatorINS3_4pairIKSA_SB_EEEEEEb:
 2037|  9.74k|                bool includeGlobalLevel = true) {
 2038|       |    // If map is empty and we are allowed to add into generic level (Level::Global), do it!
 2039|  9.74k|    if (confMap->empty() && includeGlobalLevel) {
  ------------------
  |  Branch (2039:9): [True: 9.74k, False: 0]
  |  Branch (2039:29): [True: 9.74k, False: 0]
  ------------------
 2040|  9.74k|      confMap->insert(std::make_pair(Level::Global, value));
 2041|  9.74k|      return;
 2042|  9.74k|    }
 2043|       |    // If same value exist in generic level already, dont add it to explicit level
 2044|      0|    typename std::unordered_map<Level, Conf_T>::iterator it = confMap->find(Level::Global);
 2045|      0|    if (it != confMap->end() && it->second == value) {
  ------------------
  |  Branch (2045:9): [True: 0, False: 0]
  |  Branch (2045:9): [True: 0, False: 0]
  |  Branch (2045:33): [True: 0, False: 0]
  ------------------
 2046|      0|      return;
 2047|      0|    }
 2048|       |    // Now make sure we dont double up values if we really need to add it to explicit level
 2049|      0|    it = confMap->find(level);
 2050|      0|    if (it == confMap->end()) {
  ------------------
  |  Branch (2050:9): [True: 0, False: 0]
  ------------------
 2051|       |      // Value not found for level, add new
 2052|      0|      confMap->insert(std::make_pair(level, value));
 2053|      0|    } else {
 2054|       |      // Value found, just update value
 2055|      0|      confMap->at(level) = value;
 2056|      0|    }
 2057|      0|  }
_ZN2el4base19TypedConfigurations8setValueIbEEvNS_5LevelERKT_PNSt3__113unordered_mapIS3_S4_NS7_4hashIS3_EENS7_8equal_toIS3_EENS7_9allocatorINS7_4pairIKS3_S4_EEEEEEb:
 2037|   311k|                bool includeGlobalLevel = true) {
 2038|       |    // If map is empty and we are allowed to add into generic level (Level::Global), do it!
 2039|   311k|    if (confMap->empty() && includeGlobalLevel) {
  ------------------
  |  Branch (2039:9): [True: 38.9k, False: 272k]
  |  Branch (2039:29): [True: 38.9k, False: 0]
  ------------------
 2040|  38.9k|      confMap->insert(std::make_pair(Level::Global, value));
 2041|  38.9k|      return;
 2042|  38.9k|    }
 2043|       |    // If same value exist in generic level already, dont add it to explicit level
 2044|   272k|    typename std::unordered_map<Level, Conf_T>::iterator it = confMap->find(Level::Global);
 2045|   272k|    if (it != confMap->end() && it->second == value) {
  ------------------
  |  Branch (2045:9): [True: 272k, False: 0]
  |  Branch (2045:9): [True: 272k, False: 0]
  |  Branch (2045:33): [True: 272k, False: 0]
  ------------------
 2046|   272k|      return;
 2047|   272k|    }
 2048|       |    // Now make sure we dont double up values if we really need to add it to explicit level
 2049|      0|    it = confMap->find(level);
 2050|      0|    if (it == confMap->end()) {
  ------------------
  |  Branch (2050:9): [True: 0, False: 0]
  ------------------
 2051|       |      // Value not found for level, add new
 2052|      0|      confMap->insert(std::make_pair(level, value));
 2053|      0|    } else {
 2054|       |      // Value found, just update value
 2055|      0|      confMap->at(level) = value;
 2056|      0|    }
 2057|      0|  }
_ZN2el4base19TypedConfigurations8setValueINS0_9LogFormatEEEvNS_5LevelERKT_PNSt3__113unordered_mapIS4_S5_NS8_4hashIS4_EENS8_8equal_toIS4_EENS8_9allocatorINS8_4pairIKS4_S5_EEEEEEb:
 2037|  77.9k|                bool includeGlobalLevel = true) {
 2038|       |    // If map is empty and we are allowed to add into generic level (Level::Global), do it!
 2039|  77.9k|    if (confMap->empty() && includeGlobalLevel) {
  ------------------
  |  Branch (2039:9): [True: 9.74k, False: 68.2k]
  |  Branch (2039:29): [True: 9.74k, False: 0]
  ------------------
 2040|  9.74k|      confMap->insert(std::make_pair(Level::Global, value));
 2041|  9.74k|      return;
 2042|  9.74k|    }
 2043|       |    // If same value exist in generic level already, dont add it to explicit level
 2044|  68.2k|    typename std::unordered_map<Level, Conf_T>::iterator it = confMap->find(Level::Global);
 2045|  68.2k|    if (it != confMap->end() && it->second == value) {
  ------------------
  |  Branch (2045:9): [True: 68.2k, False: 0]
  |  Branch (2045:9): [True: 0, False: 68.2k]
  |  Branch (2045:33): [True: 0, False: 68.2k]
  ------------------
 2046|      0|      return;
 2047|      0|    }
 2048|       |    // Now make sure we dont double up values if we really need to add it to explicit level
 2049|  68.2k|    it = confMap->find(level);
 2050|  68.2k|    if (it == confMap->end()) {
  ------------------
  |  Branch (2050:9): [True: 68.2k, False: 0]
  ------------------
 2051|       |      // Value not found for level, add new
 2052|  68.2k|      confMap->insert(std::make_pair(level, value));
 2053|  68.2k|    } else {
 2054|       |      // Value found, just update value
 2055|      0|      confMap->at(level) = value;
 2056|      0|    }
 2057|  68.2k|  }
_ZN2el4base19TypedConfigurations8setValueINS0_18SubsecondPrecisionEEEvNS_5LevelERKT_PNSt3__113unordered_mapIS4_S5_NS8_4hashIS4_EENS8_8equal_toIS4_EENS8_9allocatorINS8_4pairIKS4_S5_EEEEEEb:
 2037|  77.9k|                bool includeGlobalLevel = true) {
 2038|       |    // If map is empty and we are allowed to add into generic level (Level::Global), do it!
 2039|  77.9k|    if (confMap->empty() && includeGlobalLevel) {
  ------------------
  |  Branch (2039:9): [True: 9.74k, False: 68.2k]
  |  Branch (2039:29): [True: 9.74k, False: 0]
  ------------------
 2040|  9.74k|      confMap->insert(std::make_pair(Level::Global, value));
 2041|  9.74k|      return;
 2042|  9.74k|    }
 2043|       |    // If same value exist in generic level already, dont add it to explicit level
 2044|  68.2k|    typename std::unordered_map<Level, Conf_T>::iterator it = confMap->find(Level::Global);
 2045|  68.2k|    if (it != confMap->end() && it->second == value) {
  ------------------
  |  Branch (2045:9): [True: 68.2k, False: 0]
  |  Branch (2045:9): [True: 68.2k, False: 0]
  |  Branch (2045:33): [True: 68.2k, False: 0]
  ------------------
 2046|  68.2k|      return;
 2047|  68.2k|    }
 2048|       |    // Now make sure we dont double up values if we really need to add it to explicit level
 2049|      0|    it = confMap->find(level);
 2050|      0|    if (it == confMap->end()) {
  ------------------
  |  Branch (2050:9): [True: 0, False: 0]
  ------------------
 2051|       |      // Value not found for level, add new
 2052|      0|      confMap->insert(std::make_pair(level, value));
 2053|      0|    } else {
 2054|       |      // Value found, just update value
 2055|      0|      confMap->at(level) = value;
 2056|      0|    }
 2057|      0|  }
_ZN2el4base19TypedConfigurations8setValueImEEvNS_5LevelERKT_PNSt3__113unordered_mapIS3_S4_NS7_4hashIS3_EENS7_8equal_toIS3_EENS7_9allocatorINS7_4pairIKS3_S4_EEEEEEb:
 2037|   155k|                bool includeGlobalLevel = true) {
 2038|       |    // If map is empty and we are allowed to add into generic level (Level::Global), do it!
 2039|   155k|    if (confMap->empty() && includeGlobalLevel) {
  ------------------
  |  Branch (2039:9): [True: 19.4k, False: 136k]
  |  Branch (2039:29): [True: 19.4k, False: 0]
  ------------------
 2040|  19.4k|      confMap->insert(std::make_pair(Level::Global, value));
 2041|  19.4k|      return;
 2042|  19.4k|    }
 2043|       |    // If same value exist in generic level already, dont add it to explicit level
 2044|   136k|    typename std::unordered_map<Level, Conf_T>::iterator it = confMap->find(Level::Global);
 2045|   136k|    if (it != confMap->end() && it->second == value) {
  ------------------
  |  Branch (2045:9): [True: 136k, False: 0]
  |  Branch (2045:9): [True: 136k, False: 0]
  |  Branch (2045:33): [True: 136k, False: 0]
  ------------------
 2046|   136k|      return;
 2047|   136k|    }
 2048|       |    // Now make sure we dont double up values if we really need to add it to explicit level
 2049|      0|    it = confMap->find(level);
 2050|      0|    if (it == confMap->end()) {
  ------------------
  |  Branch (2050:9): [True: 0, False: 0]
  ------------------
 2051|       |      // Value not found for level, add new
 2052|      0|      confMap->insert(std::make_pair(level, value));
 2053|      0|    } else {
 2054|       |      // Value found, just update value
 2055|      0|      confMap->at(level) = value;
 2056|      0|    }
 2057|      0|  }
_ZN2el4base5utils8RegistryINS_6LoggerENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEC2Ev:
 1413|  9.74k|  Registry(void) {}
_ZN2el4base5utils16AbstractRegistryINS_6LoggerENSt3__113unordered_mapINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEPS3_NS4_4hashISB_EENS4_8equal_toISB_EENS9_INS4_4pairIKSB_SC_EEEEEEEC2Ev:
 1299|  9.74k|  AbstractRegistry(void) {}
_ZN2el4base7Storage26installLogDispatchCallbackINS0_26DefaultLogDispatchCallbackEEEbRKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE:
 2708|  9.74k|  inline bool installLogDispatchCallback(const std::string& id) {
 2709|  9.74k|    return base::utils::Utils::installCallback<T, base::type::LogDispatchCallbackPtr>(id, &m_logDispatchCallbacks);
 2710|  9.74k|  }
_ZN2el4base5utils5Utils15installCallbackINS0_26DefaultLogDispatchCallbackENSt3__110shared_ptrINS_19LogDispatchCallbackEEEEEbRKNS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEPNS5_13unordered_mapISE_T0_NS5_4hashISE_EENS5_8equal_toISE_EENSC_INS5_4pairISF_SI_EEEEEE:
 1572|  9.74k|  static bool installCallback(const std::string& id, std::unordered_map<std::string, TPtr>* mapT) {
 1573|  9.74k|    if (mapT->find(id) == mapT->end()) {
  ------------------
  |  Branch (1573:9): [True: 9.74k, False: 0]
  ------------------
 1574|  9.74k|      mapT->insert(std::make_pair(id, TPtr(new T())));
 1575|  9.74k|      return true;
 1576|  9.74k|    }
 1577|      0|    return false;
 1578|  9.74k|  }
_ZN2el8CallbackINS_15LogDispatchDataEEC2Ev:
 2184|  9.74k|  Callback(void) : m_enabled(true) {}
easylogging++.cc:_ZN2el4base5utilsL10safeDeleteINS0_21RegisteredHitCountersEEENSt3__19enable_ifIXsr3std10is_pointerIPT_EE5valueEvE4typeERS7_:
  889|  9.74k|safeDelete(T*& pointer) {
  890|  9.74k|  if (pointer == nullptr)
  ------------------
  |  Branch (890:7): [True: 0, False: 9.74k]
  ------------------
  891|      0|    return;
  892|  9.74k|  delete pointer;
  893|  9.74k|  pointer = nullptr;
  894|  9.74k|}
easylogging++.cc:_ZN2el4base5utilsL10safeDeleteINS0_17RegisteredLoggersEEENSt3__19enable_ifIXsr3std10is_pointerIPT_EE5valueEvE4typeERS7_:
  889|  9.74k|safeDelete(T*& pointer) {
  890|  9.74k|  if (pointer == nullptr)
  ------------------
  |  Branch (890:7): [True: 0, False: 9.74k]
  ------------------
  891|      0|    return;
  892|  9.74k|  delete pointer;
  893|  9.74k|  pointer = nullptr;
  894|  9.74k|}
easylogging++.cc:_ZN2el4base5utilsL10safeDeleteINS0_9VRegistryEEENSt3__19enable_ifIXsr3std10is_pointerIPT_EE5valueEvE4typeERS7_:
  889|  9.74k|safeDelete(T*& pointer) {
  890|  9.74k|  if (pointer == nullptr)
  ------------------
  |  Branch (890:7): [True: 0, False: 9.74k]
  ------------------
  891|      0|    return;
  892|  9.74k|  delete pointer;
  893|  9.74k|  pointer = nullptr;
  894|  9.74k|}

_ZN7randomx7MacroOpC2EPKciii:
   68|     24|			: name_(name), size_(size), latency_(latency), uop1_(uop), uop2_(ExecutionPort::Null) {}
_ZN7randomx7MacroOpC2EPKciiii:
   70|      6|			: name_(name), size_(size), latency_(latency), uop1_(uop1), uop2_(uop2) {}
_ZN7randomx7MacroOpC2EPKci:
   66|      4|			: name_(name), size_(size), latency_(0), uop1_(ExecutionPort::Null), uop2_(ExecutionPort::Null) {}
_ZN7randomx7MacroOpC2ERKS0_b:
   72|      2|			: name_(parent.name_), size_(parent.size_), latency_(parent.latency_), uop1_(parent.uop1_), uop2_(parent.uop2_), dependent_(dependent) {}
_ZN7randomx26SuperscalarInstructionInfoC2EPKcNS_26SuperscalarInstructionTypeERKNS_7MacroOpEi:
  210|     22|			: name_(name), type_(type), latency_(op.getLatency()), srcOp_(srcOp) {
  211|     22|			ops_.push_back(MacroOp(op));
  212|     22|		}
_ZN7randomx26SuperscalarInstructionInfoC2EPKc:
  208|      2|			: name_(name), type_(SuperscalarInstructionType::INVALID), latency_(0) {}
_ZN7randomx13DecoderBufferC2Ev:
  295|      2|		DecoderBuffer() : index_(-1) {}
_ZN7randomx22SuperscalarInstructionC2EPKNS_26SuperscalarInstructionInfoE:
  576|      2|		SuperscalarInstruction(const SuperscalarInstructionInfo* info) : info_(info) {
  577|      2|		}
_ZNK7randomx7MacroOp10getLatencyEv:
   79|     38|		int getLatency() const {
   80|     38|			return latency_;
   81|     38|		}
_ZN7randomx26SuperscalarInstructionInfoC2ILm3EEEPKcNS_26SuperscalarInstructionTypeERAT__KNS_7MacroOpEiii:
  215|      4|			: name_(name), type_(type), latency_(0), resultOp_(resultOp), dstOp_(dstOp), srcOp_(srcOp) {
  216|     16|			for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (216:25): [True: 12, False: 4]
  ------------------
  217|     12|				ops_.push_back(MacroOp(arr[i]));
  218|     12|				latency_ += ops_.back().getLatency();
  219|     12|			}
  220|      4|			static_assert(N > 1, "Invalid array size");
  221|      4|		}
_ZN7randomx26SuperscalarInstructionInfoC2ILm2EEEPKcNS_26SuperscalarInstructionTypeERAT__KNS_7MacroOpEiii:
  215|      2|			: name_(name), type_(type), latency_(0), resultOp_(resultOp), dstOp_(dstOp), srcOp_(srcOp) {
  216|      6|			for (unsigned i = 0; i < N; ++i) {
  ------------------
  |  Branch (216:25): [True: 4, False: 2]
  ------------------
  217|      4|				ops_.push_back(MacroOp(arr[i]));
  218|      4|				latency_ += ops_.back().getLatency();
  219|      4|			}
  220|      2|			static_assert(N > 1, "Invalid array size");
  221|      2|		}
_ZN7randomx13DecoderBufferC2ILm3EEEPKciRAT__Ki:
  258|      6|			: name_(name), index_(index), counts_(arr), opsCount_(N) {}
_ZN7randomx13DecoderBufferC2ILm4EEEPKciRAT__Ki:
  258|      6|			: name_(name), index_(index), counts_(arr), opsCount_(N) {}

crypto_sign_ed25519_amd64_64_fe25519_getparity:
    4|   187k|{
    5|   187k|  fe25519 t = *x;
  ------------------
  |  |    4|   187k|#define fe25519                crypto_sign_ed25519_amd64_64_fe25519
  ------------------
    6|   187k|  fe25519_freeze(&t);
  ------------------
  |  |    5|   187k|#define fe25519_freeze         crypto_sign_ed25519_amd64_64_fe25519_freeze
  ------------------
    7|   187k|  return (unsigned char)t.v[0] & 1;
    8|   187k|}

crypto_sign_ed25519_amd64_64_fe25519_invert:
    4|  93.6k|{
    5|  93.6k|	fe25519 z2;
  ------------------
  |  |    4|  93.6k|#define fe25519                crypto_sign_ed25519_amd64_64_fe25519
  ------------------
    6|  93.6k|	fe25519 z9;
  ------------------
  |  |    4|  93.6k|#define fe25519                crypto_sign_ed25519_amd64_64_fe25519
  ------------------
    7|  93.6k|	fe25519 z11;
  ------------------
  |  |    4|  93.6k|#define fe25519                crypto_sign_ed25519_amd64_64_fe25519
  ------------------
    8|  93.6k|	fe25519 z2_5_0;
  ------------------
  |  |    4|  93.6k|#define fe25519                crypto_sign_ed25519_amd64_64_fe25519
  ------------------
    9|  93.6k|	fe25519 z2_10_0;
  ------------------
  |  |    4|  93.6k|#define fe25519                crypto_sign_ed25519_amd64_64_fe25519
  ------------------
   10|  93.6k|	fe25519 z2_20_0;
  ------------------
  |  |    4|  93.6k|#define fe25519                crypto_sign_ed25519_amd64_64_fe25519
  ------------------
   11|  93.6k|	fe25519 z2_50_0;
  ------------------
  |  |    4|  93.6k|#define fe25519                crypto_sign_ed25519_amd64_64_fe25519
  ------------------
   12|  93.6k|	fe25519 z2_100_0;
  ------------------
  |  |    4|  93.6k|#define fe25519                crypto_sign_ed25519_amd64_64_fe25519
  ------------------
   13|  93.6k|	fe25519 t;
  ------------------
  |  |    4|  93.6k|#define fe25519                crypto_sign_ed25519_amd64_64_fe25519
  ------------------
   14|  93.6k|	int i;
   15|       |	
   16|  93.6k|	/* 2 */ fe25519_square(&z2,x);
  ------------------
  |  |   18|  93.6k|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
   17|  93.6k|	/* 4 */ fe25519_square(&t,&z2);
  ------------------
  |  |   18|  93.6k|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
   18|  93.6k|	/* 8 */ fe25519_square(&t,&t);
  ------------------
  |  |   18|  93.6k|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
   19|  93.6k|	/* 9 */ fe25519_mul(&z9,&t,x);
  ------------------
  |  |   16|  93.6k|#define fe25519_mul            crypto_sign_ed25519_amd64_64_fe25519_mul
  ------------------
   20|  93.6k|	/* 11 */ fe25519_mul(&z11,&z9,&z2);
  ------------------
  |  |   16|  93.6k|#define fe25519_mul            crypto_sign_ed25519_amd64_64_fe25519_mul
  ------------------
   21|  93.6k|	/* 22 */ fe25519_square(&t,&z11);
  ------------------
  |  |   18|  93.6k|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
   22|  93.6k|	/* 2^5 - 2^0 = 31 */ fe25519_mul(&z2_5_0,&t,&z9);
  ------------------
  |  |   16|  93.6k|#define fe25519_mul            crypto_sign_ed25519_amd64_64_fe25519_mul
  ------------------
   23|       |
   24|  93.6k|	/* 2^6 - 2^1 */ fe25519_square(&t,&z2_5_0);
  ------------------
  |  |   18|  93.6k|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
   25|   468k|	/* 2^20 - 2^10 */ for (i = 1;i < 5;i++) { fe25519_square(&t,&t); }
  ------------------
  |  |   18|   374k|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
  |  Branch (25:31): [True: 374k, False: 93.6k]
  ------------------
   26|  93.6k|	/* 2^10 - 2^0 */ fe25519_mul(&z2_10_0,&t,&z2_5_0);
  ------------------
  |  |   16|  93.6k|#define fe25519_mul            crypto_sign_ed25519_amd64_64_fe25519_mul
  ------------------
   27|       |
   28|  93.6k|	/* 2^11 - 2^1 */ fe25519_square(&t,&z2_10_0);
  ------------------
  |  |   18|  93.6k|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
   29|   936k|	/* 2^20 - 2^10 */ for (i = 1;i < 10;i++) { fe25519_square(&t,&t); }
  ------------------
  |  |   18|   842k|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
  |  Branch (29:31): [True: 842k, False: 93.6k]
  ------------------
   30|  93.6k|	/* 2^20 - 2^0 */ fe25519_mul(&z2_20_0,&t,&z2_10_0);
  ------------------
  |  |   16|  93.6k|#define fe25519_mul            crypto_sign_ed25519_amd64_64_fe25519_mul
  ------------------
   31|       |
   32|  93.6k|	/* 2^21 - 2^1 */ fe25519_square(&t,&z2_20_0);
  ------------------
  |  |   18|  93.6k|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
   33|  1.87M|	/* 2^40 - 2^20 */ for (i = 1;i < 20;i++) { fe25519_square(&t,&t); }
  ------------------
  |  |   18|  1.77M|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
  |  Branch (33:31): [True: 1.77M, False: 93.6k]
  ------------------
   34|  93.6k|	/* 2^40 - 2^0 */ fe25519_mul(&t,&t,&z2_20_0);
  ------------------
  |  |   16|  93.6k|#define fe25519_mul            crypto_sign_ed25519_amd64_64_fe25519_mul
  ------------------
   35|       |
   36|  93.6k|	/* 2^41 - 2^1 */ fe25519_square(&t,&t);
  ------------------
  |  |   18|  93.6k|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
   37|   936k|	/* 2^50 - 2^10 */ for (i = 1;i < 10;i++) { fe25519_square(&t,&t); }
  ------------------
  |  |   18|   842k|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
  |  Branch (37:31): [True: 842k, False: 93.6k]
  ------------------
   38|  93.6k|	/* 2^50 - 2^0 */ fe25519_mul(&z2_50_0,&t,&z2_10_0);
  ------------------
  |  |   16|  93.6k|#define fe25519_mul            crypto_sign_ed25519_amd64_64_fe25519_mul
  ------------------
   39|       |
   40|  93.6k|	/* 2^51 - 2^1 */ fe25519_square(&t,&z2_50_0);
  ------------------
  |  |   18|  93.6k|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
   41|  4.68M|	/* 2^100 - 2^50 */ for (i = 1;i < 50;i++) { fe25519_square(&t,&t); }
  ------------------
  |  |   18|  4.58M|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
  |  Branch (41:32): [True: 4.58M, False: 93.6k]
  ------------------
   42|  93.6k|	/* 2^100 - 2^0 */ fe25519_mul(&z2_100_0,&t,&z2_50_0);
  ------------------
  |  |   16|  93.6k|#define fe25519_mul            crypto_sign_ed25519_amd64_64_fe25519_mul
  ------------------
   43|       |
   44|  93.6k|	/* 2^101 - 2^1 */ fe25519_square(&t,&z2_100_0);
  ------------------
  |  |   18|  93.6k|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
   45|  9.36M|	/* 2^200 - 2^100 */ for (i = 1;i < 100;i++) { fe25519_square(&t,&t); }
  ------------------
  |  |   18|  9.27M|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
  |  Branch (45:33): [True: 9.27M, False: 93.6k]
  ------------------
   46|  93.6k|	/* 2^200 - 2^0 */ fe25519_mul(&t,&t,&z2_100_0);
  ------------------
  |  |   16|  93.6k|#define fe25519_mul            crypto_sign_ed25519_amd64_64_fe25519_mul
  ------------------
   47|       |
   48|  93.6k|	/* 2^201 - 2^1 */ fe25519_square(&t,&t);
  ------------------
  |  |   18|  93.6k|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
   49|  4.68M|	/* 2^250 - 2^50 */ for (i = 1;i < 50;i++) { fe25519_square(&t,&t); }
  ------------------
  |  |   18|  4.58M|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
  |  Branch (49:32): [True: 4.58M, False: 93.6k]
  ------------------
   50|  93.6k|	/* 2^250 - 2^0 */ fe25519_mul(&t,&t,&z2_50_0);
  ------------------
  |  |   16|  93.6k|#define fe25519_mul            crypto_sign_ed25519_amd64_64_fe25519_mul
  ------------------
   51|       |
   52|  93.6k|	/* 2^251 - 2^1 */ fe25519_square(&t,&t);
  ------------------
  |  |   18|  93.6k|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
   53|  93.6k|	/* 2^252 - 2^2 */ fe25519_square(&t,&t);
  ------------------
  |  |   18|  93.6k|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
   54|  93.6k|	/* 2^253 - 2^3 */ fe25519_square(&t,&t);
  ------------------
  |  |   18|  93.6k|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
   55|       |
   56|  93.6k|	/* 2^254 - 2^4 */ fe25519_square(&t,&t);
  ------------------
  |  |   18|  93.6k|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
   57|       |
   58|  93.6k|	/* 2^255 - 2^5 */ fe25519_square(&t,&t);
  ------------------
  |  |   18|  93.6k|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
   59|  93.6k|	/* 2^255 - 21 */ fe25519_mul(r,&t,&z11);
  ------------------
  |  |   16|  93.6k|#define fe25519_mul            crypto_sign_ed25519_amd64_64_fe25519_mul
  ------------------
   60|  93.6k|}

crypto_sign_ed25519_amd64_64_fe25519_iseq_vartime:
    4|   271k|{
    5|   271k|  fe25519 t1 = *x;
  ------------------
  |  |    4|   271k|#define fe25519                crypto_sign_ed25519_amd64_64_fe25519
  ------------------
    6|   271k|  fe25519 t2 = *y;
  ------------------
  |  |    4|   271k|#define fe25519                crypto_sign_ed25519_amd64_64_fe25519
  ------------------
    7|   271k|  fe25519_freeze(&t1);
  ------------------
  |  |    5|   271k|#define fe25519_freeze         crypto_sign_ed25519_amd64_64_fe25519_freeze
  ------------------
    8|   271k|  fe25519_freeze(&t2);
  ------------------
  |  |    5|   271k|#define fe25519_freeze         crypto_sign_ed25519_amd64_64_fe25519_freeze
  ------------------
    9|   271k|  if(t1.v[0] != t2.v[0]) return 0;
  ------------------
  |  Branch (9:6): [True: 158k, False: 113k]
  ------------------
   10|   113k|  if(t1.v[1] != t2.v[1]) return 0;
  ------------------
  |  Branch (10:6): [True: 0, False: 113k]
  ------------------
   11|   113k|  if(t1.v[2] != t2.v[2]) return 0;
  ------------------
  |  Branch (11:6): [True: 0, False: 113k]
  ------------------
   12|   113k|  if(t1.v[3] != t2.v[3]) return 0;
  ------------------
  |  Branch (12:6): [True: 0, False: 113k]
  ------------------
   13|   113k|  return 1;
   14|   113k|}

crypto_sign_ed25519_amd64_64_fe25519_neg:
    4|  36.5k|{
    5|  36.5k|  fe25519 t;
  ------------------
  |  |    4|  36.5k|#define fe25519                crypto_sign_ed25519_amd64_64_fe25519
  ------------------
    6|  36.5k|  fe25519_setint(&t,0);
  ------------------
  |  |   11|  36.5k|#define fe25519_setint         crypto_sign_ed25519_amd64_64_fe25519_setint
  ------------------
    7|  36.5k|  fe25519_sub(r,&t,x);
  ------------------
  |  |   15|  36.5k|#define fe25519_sub            crypto_sign_ed25519_amd64_64_fe25519_sub
  ------------------
    8|  36.5k|}

crypto_sign_ed25519_amd64_64_fe25519_pack:
    5|  93.6k|{
    6|  93.6k|  int i;
    7|  93.6k|  fe25519 t;
  ------------------
  |  |    4|  93.6k|#define fe25519                crypto_sign_ed25519_amd64_64_fe25519
  ------------------
    8|  93.6k|  t = *x;
    9|  93.6k|  fe25519_freeze(&t);
  ------------------
  |  |    5|  93.6k|#define fe25519_freeze         crypto_sign_ed25519_amd64_64_fe25519_freeze
  ------------------
   10|       |  /* assuming little-endian */
   11|  3.09M|  for(i=0;i<32;i++) r[i] = i[(unsigned char *)&t.v]; 
  ------------------
  |  Branch (11:11): [True: 2.99M, False: 93.6k]
  ------------------
   12|  93.6k|}

crypto_sign_ed25519_amd64_64_fe25519_pow2523:
    4|   135k|{
    5|   135k|	fe25519 z2;
  ------------------
  |  |    4|   135k|#define fe25519                crypto_sign_ed25519_amd64_64_fe25519
  ------------------
    6|   135k|	fe25519 z9;
  ------------------
  |  |    4|   135k|#define fe25519                crypto_sign_ed25519_amd64_64_fe25519
  ------------------
    7|   135k|	fe25519 z11;
  ------------------
  |  |    4|   135k|#define fe25519                crypto_sign_ed25519_amd64_64_fe25519
  ------------------
    8|   135k|	fe25519 z2_5_0;
  ------------------
  |  |    4|   135k|#define fe25519                crypto_sign_ed25519_amd64_64_fe25519
  ------------------
    9|   135k|	fe25519 z2_10_0;
  ------------------
  |  |    4|   135k|#define fe25519                crypto_sign_ed25519_amd64_64_fe25519
  ------------------
   10|   135k|	fe25519 z2_20_0;
  ------------------
  |  |    4|   135k|#define fe25519                crypto_sign_ed25519_amd64_64_fe25519
  ------------------
   11|   135k|	fe25519 z2_50_0;
  ------------------
  |  |    4|   135k|#define fe25519                crypto_sign_ed25519_amd64_64_fe25519
  ------------------
   12|   135k|	fe25519 z2_100_0;
  ------------------
  |  |    4|   135k|#define fe25519                crypto_sign_ed25519_amd64_64_fe25519
  ------------------
   13|   135k|	fe25519 t;
  ------------------
  |  |    4|   135k|#define fe25519                crypto_sign_ed25519_amd64_64_fe25519
  ------------------
   14|   135k|	int i;
   15|       |		
   16|   135k|	/* 2 */ fe25519_square(&z2,x);
  ------------------
  |  |   18|   135k|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
   17|   135k|	/* 4 */ fe25519_square(&t,&z2);
  ------------------
  |  |   18|   135k|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
   18|   135k|	/* 8 */ fe25519_square(&t,&t);
  ------------------
  |  |   18|   135k|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
   19|   135k|	/* 9 */ fe25519_mul(&z9,&t,x);
  ------------------
  |  |   16|   135k|#define fe25519_mul            crypto_sign_ed25519_amd64_64_fe25519_mul
  ------------------
   20|   135k|	/* 11 */ fe25519_mul(&z11,&z9,&z2);
  ------------------
  |  |   16|   135k|#define fe25519_mul            crypto_sign_ed25519_amd64_64_fe25519_mul
  ------------------
   21|   135k|	/* 22 */ fe25519_square(&t,&z11);
  ------------------
  |  |   18|   135k|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
   22|   135k|	/* 2^5 - 2^0 = 31 */ fe25519_mul(&z2_5_0,&t,&z9);
  ------------------
  |  |   16|   135k|#define fe25519_mul            crypto_sign_ed25519_amd64_64_fe25519_mul
  ------------------
   23|       |
   24|   135k|	/* 2^6 - 2^1 */ fe25519_square(&t,&z2_5_0);
  ------------------
  |  |   18|   135k|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
   25|   679k|	/* 2^10 - 2^5 */ for (i = 1;i < 5;i++) { fe25519_square(&t,&t); }
  ------------------
  |  |   18|   543k|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
  |  Branch (25:30): [True: 543k, False: 135k]
  ------------------
   26|   135k|	/* 2^10 - 2^0 */ fe25519_mul(&z2_10_0,&t,&z2_5_0);
  ------------------
  |  |   16|   135k|#define fe25519_mul            crypto_sign_ed25519_amd64_64_fe25519_mul
  ------------------
   27|       |
   28|   135k|	/* 2^11 - 2^1 */ fe25519_square(&t,&z2_10_0);
  ------------------
  |  |   18|   135k|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
   29|  1.35M|	/* 2^20 - 2^10 */ for (i = 1;i < 10;i++) { fe25519_square(&t,&t); }
  ------------------
  |  |   18|  1.22M|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
  |  Branch (29:31): [True: 1.22M, False: 135k]
  ------------------
   30|   135k|	/* 2^20 - 2^0 */ fe25519_mul(&z2_20_0,&t,&z2_10_0);
  ------------------
  |  |   16|   135k|#define fe25519_mul            crypto_sign_ed25519_amd64_64_fe25519_mul
  ------------------
   31|       |
   32|   135k|	/* 2^21 - 2^1 */ fe25519_square(&t,&z2_20_0);
  ------------------
  |  |   18|   135k|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
   33|  2.71M|	/* 2^40 - 2^20 */ for (i = 1;i < 20;i++) { fe25519_square(&t,&t); }
  ------------------
  |  |   18|  2.58M|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
  |  Branch (33:31): [True: 2.58M, False: 135k]
  ------------------
   34|   135k|	/* 2^40 - 2^0 */ fe25519_mul(&t,&t,&z2_20_0);
  ------------------
  |  |   16|   135k|#define fe25519_mul            crypto_sign_ed25519_amd64_64_fe25519_mul
  ------------------
   35|       |
   36|   135k|	/* 2^41 - 2^1 */ fe25519_square(&t,&t);
  ------------------
  |  |   18|   135k|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
   37|  1.35M|	/* 2^50 - 2^10 */ for (i = 1;i < 10;i++) { fe25519_square(&t,&t); }
  ------------------
  |  |   18|  1.22M|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
  |  Branch (37:31): [True: 1.22M, False: 135k]
  ------------------
   38|   135k|	/* 2^50 - 2^0 */ fe25519_mul(&z2_50_0,&t,&z2_10_0);
  ------------------
  |  |   16|   135k|#define fe25519_mul            crypto_sign_ed25519_amd64_64_fe25519_mul
  ------------------
   39|       |
   40|   135k|	/* 2^51 - 2^1 */ fe25519_square(&t,&z2_50_0);
  ------------------
  |  |   18|   135k|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
   41|  6.79M|	/* 2^100 - 2^50 */ for (i = 1;i < 50;i++) { fe25519_square(&t,&t); }
  ------------------
  |  |   18|  6.66M|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
  |  Branch (41:32): [True: 6.66M, False: 135k]
  ------------------
   42|   135k|	/* 2^100 - 2^0 */ fe25519_mul(&z2_100_0,&t,&z2_50_0);
  ------------------
  |  |   16|   135k|#define fe25519_mul            crypto_sign_ed25519_amd64_64_fe25519_mul
  ------------------
   43|       |
   44|   135k|	/* 2^101 - 2^1 */ fe25519_square(&t,&z2_100_0);
  ------------------
  |  |   18|   135k|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
   45|  13.5M|	/* 2^200 - 2^100 */ for (i = 1;i < 100;i++) { fe25519_square(&t,&t); }
  ------------------
  |  |   18|  13.4M|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
  |  Branch (45:33): [True: 13.4M, False: 135k]
  ------------------
   46|   135k|	/* 2^200 - 2^0 */ fe25519_mul(&t,&t,&z2_100_0);
  ------------------
  |  |   16|   135k|#define fe25519_mul            crypto_sign_ed25519_amd64_64_fe25519_mul
  ------------------
   47|       |
   48|   135k|	/* 2^201 - 2^1 */ fe25519_square(&t,&t);
  ------------------
  |  |   18|   135k|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
   49|  6.79M|	/* 2^250 - 2^50 */ for (i = 1;i < 50;i++) { fe25519_square(&t,&t); }
  ------------------
  |  |   18|  6.66M|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
  |  Branch (49:32): [True: 6.66M, False: 135k]
  ------------------
   50|   135k|	/* 2^250 - 2^0 */ fe25519_mul(&t,&t,&z2_50_0);
  ------------------
  |  |   16|   135k|#define fe25519_mul            crypto_sign_ed25519_amd64_64_fe25519_mul
  ------------------
   51|       |
   52|   135k|	/* 2^251 - 2^1 */ fe25519_square(&t,&t);
  ------------------
  |  |   18|   135k|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
   53|   135k|	/* 2^252 - 2^2 */ fe25519_square(&t,&t);
  ------------------
  |  |   18|   135k|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
   54|   135k|	/* 2^252 - 3 */ fe25519_mul(r,&t,x);
  ------------------
  |  |   16|   135k|#define fe25519_mul            crypto_sign_ed25519_amd64_64_fe25519_mul
  ------------------
   55|   135k|}

crypto_sign_ed25519_amd64_64_fe25519_setint:
    4|   528k|{
    5|   528k|  r->v[0] = v;
    6|   528k|  r->v[1] = 0;
    7|   528k|  r->v[2] = 0;
    8|   528k|  r->v[3] = 0;
    9|   528k|}

crypto_sign_ed25519_amd64_64_fe25519_unpack:
    4|   135k|{
    5|       |  /* assuming little-endian */
    6|   135k|  r->v[0] = *(unsigned long long *)x;
    7|   135k|  r->v[1] = *(((unsigned long long *)x)+1);
    8|   135k|  r->v[2] = *(((unsigned long long *)x)+2);
    9|   135k|  r->v[3] = *(((unsigned long long *)x)+3);
   10|   135k|  r->v[3] &= 0x7fffffffffffffffULL;
   11|   135k|}

crypto_sign_ed25519_amd64_64_ge25519_add:
    4|  6.32k|{
    5|  6.32k|  ge25519_p1p1 grp1p1;
    6|  6.32k|  ge25519_add_p1p1(&grp1p1, p, q);
  ------------------
  |  |   19|  6.32k|#define ge25519_add_p1p1                  crypto_sign_ed25519_amd64_64_ge25519_add_p1p1
  ------------------
    7|  6.32k|  ge25519_p1p1_to_p3(r, &grp1p1);
  ------------------
  |  |   18|  6.32k|#define ge25519_p1p1_to_p3                crypto_sign_ed25519_amd64_64_ge25519_p1p1_to_p3
  ------------------
    8|  6.32k|}

crypto_sign_ed25519_amd64_64_pack:
    6|  93.6k|{
    7|  93.6k|  fe25519 tx, ty, zi;
  ------------------
  |  |    4|  93.6k|#define fe25519                crypto_sign_ed25519_amd64_64_fe25519
  ------------------
    8|  93.6k|  fe25519_invert(&zi, &p->z); 
  ------------------
  |  |   19|  93.6k|#define fe25519_invert         crypto_sign_ed25519_amd64_64_fe25519_invert
  ------------------
    9|  93.6k|  fe25519_mul(&tx, &p->x, &zi);
  ------------------
  |  |   16|  93.6k|#define fe25519_mul            crypto_sign_ed25519_amd64_64_fe25519_mul
  ------------------
   10|  93.6k|  fe25519_mul(&ty, &p->y, &zi);
  ------------------
  |  |   16|  93.6k|#define fe25519_mul            crypto_sign_ed25519_amd64_64_fe25519_mul
  ------------------
   11|  93.6k|  fe25519_pack(r, &ty);
  ------------------
  |  |    7|  93.6k|#define fe25519_pack           crypto_sign_ed25519_amd64_64_fe25519_pack
  ------------------
   12|  93.6k|  r[31] ^= fe25519_getparity(&tx) << 7;
  ------------------
  |  |   13|  93.6k|#define fe25519_getparity      crypto_sign_ed25519_amd64_64_fe25519_getparity
  ------------------
   13|  93.6k|}

crypto_sign_ed25519_amd64_64_scalarmult_base:
   18|  6.32k|{
   19|  6.32k|  signed char b[64];
   20|  6.32k|  int i;
   21|  6.32k|  ge25519_niels t;
   22|  6.32k|  fe25519 d;
  ------------------
  |  |    4|  6.32k|#define fe25519                crypto_sign_ed25519_amd64_64_fe25519
  ------------------
   23|       |
   24|  6.32k|  sc25519_window4(b,s);
  ------------------
  |  |   18|  6.32k|#define sc25519_window4          crypto_sign_ed25519_amd64_64_sc25519_window4
  ------------------
   25|       |
   26|       |#ifdef SMALLTABLES
   27|       |  ge25519_p1p1 tp1p1;
   28|       |  choose_t((ge25519_niels *)r, 0, (signed long long) b[1], ge25519_base_multiples_niels);
   29|       |  fe25519_sub(&d, &r->y, &r->x);
   30|       |  fe25519_add(&r->y, &r->y, &r->x);
   31|       |  r->x = d;
   32|       |  r->t = r->z;
   33|       |  fe25519_setint(&r->z,2);
   34|       |  for(i=3;i<64;i+=2)
   35|       |  {
   36|       |    choose_t(&t, (unsigned long long) i/2, (signed long long) b[i], ge25519_base_multiples_niels);
   37|       |    ge25519_nielsadd2(r, &t);
   38|       |  }
   39|       |  ge25519_dbl_p1p1(&tp1p1,(ge25519_p2 *)r);
   40|       |  ge25519_p1p1_to_p2((ge25519_p2 *)r, &tp1p1);
   41|       |  ge25519_dbl_p1p1(&tp1p1,(ge25519_p2 *)r);
   42|       |  ge25519_p1p1_to_p2((ge25519_p2 *)r, &tp1p1);
   43|       |  ge25519_dbl_p1p1(&tp1p1,(ge25519_p2 *)r);
   44|       |  ge25519_p1p1_to_p2((ge25519_p2 *)r, &tp1p1);
   45|       |  ge25519_dbl_p1p1(&tp1p1,(ge25519_p2 *)r);
   46|       |  ge25519_p1p1_to_p3(r, &tp1p1);
   47|       |  choose_t(&t, (unsigned long long) 0, (signed long long) b[0], ge25519_base_multiples_niels);
   48|       |  fe25519_mul(&t.t2d, &t.t2d, &ecd);
   49|       |  ge25519_nielsadd2(r, &t);
   50|       |  for(i=2;i<64;i+=2)
   51|       |  {
   52|       |    choose_t(&t, (unsigned long long) i/2, (signed long long) b[i], ge25519_base_multiples_niels);
   53|       |    ge25519_nielsadd2(r, &t);
   54|       |  }
   55|       |#else 
   56|  6.32k|  choose_t((ge25519_niels *)r, 0, (signed long long) b[0], ge25519_base_multiples_niels);
  ------------------
  |  |   21|  6.32k|#define choose_t                          crypto_sign_ed25519_amd64_64_choose_t
  ------------------
   57|  6.32k|  fe25519_sub(&d, &r->y, &r->x);
  ------------------
  |  |   15|  6.32k|#define fe25519_sub            crypto_sign_ed25519_amd64_64_fe25519_sub
  ------------------
   58|  6.32k|  fe25519_add(&r->y, &r->y, &r->x);
  ------------------
  |  |   14|  6.32k|#define fe25519_add            crypto_sign_ed25519_amd64_64_fe25519_add
  ------------------
   59|  6.32k|  r->x = d;
   60|  6.32k|  r->t = r->z;
   61|  6.32k|  fe25519_setint(&r->z,2);
  ------------------
  |  |   11|  6.32k|#define fe25519_setint         crypto_sign_ed25519_amd64_64_fe25519_setint
  ------------------
   62|   404k|  for(i=1;i<64;i++)
  ------------------
  |  Branch (62:11): [True: 398k, False: 6.32k]
  ------------------
   63|   398k|  {
   64|   398k|    choose_t(&t, (unsigned long long) i, (signed long long) b[i], ge25519_base_multiples_niels);
  ------------------
  |  |   21|   398k|#define choose_t                          crypto_sign_ed25519_amd64_64_choose_t
  ------------------
   65|   398k|    ge25519_nielsadd2(r, &t);
  ------------------
  |  |   22|   398k|#define ge25519_nielsadd2                 crypto_sign_ed25519_amd64_64_ge25519_nielsadd2
  ------------------
   66|   398k|  }
   67|  6.32k|#endif 
   68|  6.32k|}

crypto_sign_ed25519_amd64_64_sc25519_window4:
    4|  93.6k|{
    5|  93.6k|  char carry;
    6|  93.6k|  int i;
    7|  1.59M|  for(i=0;i<16;i++)
  ------------------
  |  Branch (7:11): [True: 1.49M, False: 93.6k]
  ------------------
    8|  1.49M|    r[i] = (s->v[0] >> (4*i)) & 15;
    9|  1.59M|  for(i=0;i<16;i++)
  ------------------
  |  Branch (9:11): [True: 1.49M, False: 93.6k]
  ------------------
   10|  1.49M|    r[i+16] = (s->v[1] >> (4*i)) & 15;
   11|  1.59M|  for(i=0;i<16;i++)
  ------------------
  |  Branch (11:11): [True: 1.49M, False: 93.6k]
  ------------------
   12|  1.49M|    r[i+32] = (s->v[2] >> (4*i)) & 15;
   13|  1.59M|  for(i=0;i<16;i++)
  ------------------
  |  Branch (13:11): [True: 1.49M, False: 93.6k]
  ------------------
   14|  1.49M|    r[i+48] = (s->v[3] >> (4*i)) & 15;
   15|       |
   16|       |  /* Making it signed */
   17|  93.6k|  carry = 0;
   18|  5.99M|  for(i=0;i<63;i++)
  ------------------
  |  Branch (18:11): [True: 5.90M, False: 93.6k]
  ------------------
   19|  5.90M|  {
   20|  5.90M|    r[i] += carry;
   21|  5.90M|    r[i+1] += r[i] >> 4;
   22|  5.90M|    r[i] &= 15;
   23|  5.90M|    carry = r[i] >> 3;
   24|  5.90M|    r[i] -= carry << 4;
   25|  5.90M|  }
   26|  93.6k|  r[63] += carry;
   27|  93.6k|}

monero_crypto_amd64_64_24k_generate_key_derivation:
   68|   125k|{
   69|   125k|  return generate_key_derivation(out, tx_pub, view_sec);
   70|   125k|}
monero_crypto_amd64_64_24k_generate_subaddress_public_key:
   73|  9.97k|{
   74|  9.97k|  return generate_subaddress_public_key(out, output_pub, special_sec);
   75|  9.97k|}
amd64-64-24k.c:ge25519_p1p1_to_pniels:
   51|   611k|{
   52|   611k|  ge25519_p1p1_to_p3((ge25519_p3*)out, in);
  ------------------
  |  |   18|   611k|#define ge25519_p1p1_to_p3                crypto_sign_ed25519_amd64_64_ge25519_p1p1_to_p3
  ------------------
   53|   611k|  const fe25519 d = out->ysubx;
   54|   611k|  fe25519_sub(&(out->ysubx), &(out->xaddy), &(out->ysubx));
  ------------------
  |  |   15|   611k|#define fe25519_sub            crypto_sign_ed25519_amd64_64_fe25519_sub
  ------------------
   55|   611k|  fe25519_add(&(out->xaddy), &(out->xaddy), &d);
  ------------------
  |  |   14|   611k|#define fe25519_add            crypto_sign_ed25519_amd64_64_fe25519_add
  ------------------
   56|   611k|  fe25519_mul(&(out->t2d), &(out->t2d), &ec2d);
  ------------------
  |  |   16|   611k|#define fe25519_mul            crypto_sign_ed25519_amd64_64_fe25519_mul
  ------------------
   57|   611k|}

amd64-64-24k.c:unpack_vartime:
   44|   135k|{
   45|   135k|  fe25519 t, chk, num, den, den2, den4, den6;
  ------------------
  |  |    4|   135k|#define fe25519                crypto_sign_ed25519_amd64_64_fe25519
  ------------------
   46|   135k|  unsigned char par = p[31] >> 7;
   47|       |
   48|   135k|  fe25519_setint(&r->z,1);
  ------------------
  |  |   11|   135k|#define fe25519_setint         crypto_sign_ed25519_amd64_64_fe25519_setint
  ------------------
   49|   135k|  fe25519_unpack(&r->y, p); 
  ------------------
  |  |    6|   135k|#define fe25519_unpack         crypto_sign_ed25519_amd64_64_fe25519_unpack
  ------------------
   50|   135k|  fe25519_square(&num, &r->y); /* x = y^2 */
  ------------------
  |  |   18|   135k|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
   51|   135k|  fe25519_mul(&den, &num, &ecd); /* den = dy^2 */
  ------------------
  |  |   16|   135k|#define fe25519_mul            crypto_sign_ed25519_amd64_64_fe25519_mul
  ------------------
   52|   135k|  fe25519_sub(&num, &num, &r->z); /* x = y^2-1 */
  ------------------
  |  |   15|   135k|#define fe25519_sub            crypto_sign_ed25519_amd64_64_fe25519_sub
  ------------------
   53|   135k|  fe25519_add(&den, &r->z, &den); /* den = dy^2+1 */
  ------------------
  |  |   14|   135k|#define fe25519_add            crypto_sign_ed25519_amd64_64_fe25519_add
  ------------------
   54|       |
   55|       |  /* Computation of sqrt(num/den)
   56|       |     1.: computation of num^((p-5)/8)*den^((7p-35)/8) = (num*den^7)^((p-5)/8)
   57|       |  */
   58|   135k|  fe25519_square(&den2, &den);
  ------------------
  |  |   18|   135k|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
   59|   135k|  fe25519_square(&den4, &den2);
  ------------------
  |  |   18|   135k|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
   60|   135k|  fe25519_mul(&den6, &den4, &den2);
  ------------------
  |  |   16|   135k|#define fe25519_mul            crypto_sign_ed25519_amd64_64_fe25519_mul
  ------------------
   61|   135k|  fe25519_mul(&t, &den6, &num);
  ------------------
  |  |   16|   135k|#define fe25519_mul            crypto_sign_ed25519_amd64_64_fe25519_mul
  ------------------
   62|   135k|  fe25519_mul(&t, &t, &den);
  ------------------
  |  |   16|   135k|#define fe25519_mul            crypto_sign_ed25519_amd64_64_fe25519_mul
  ------------------
   63|       |
   64|   135k|  fe25519_pow2523(&t, &t);
  ------------------
  |  |   20|   135k|#define fe25519_pow2523        crypto_sign_ed25519_amd64_64_fe25519_pow2523
  ------------------
   65|       |  /* 2. computation of r->x = t * num * den^3
   66|       |  */
   67|   135k|  fe25519_mul(&t, &t, &num);
  ------------------
  |  |   16|   135k|#define fe25519_mul            crypto_sign_ed25519_amd64_64_fe25519_mul
  ------------------
   68|   135k|  fe25519_mul(&t, &t, &den);
  ------------------
  |  |   16|   135k|#define fe25519_mul            crypto_sign_ed25519_amd64_64_fe25519_mul
  ------------------
   69|   135k|  fe25519_mul(&t, &t, &den);
  ------------------
  |  |   16|   135k|#define fe25519_mul            crypto_sign_ed25519_amd64_64_fe25519_mul
  ------------------
   70|   135k|  fe25519_mul(&r->x, &t, &den);
  ------------------
  |  |   16|   135k|#define fe25519_mul            crypto_sign_ed25519_amd64_64_fe25519_mul
  ------------------
   71|       |
   72|       |  /* 3. Check whether sqrt computation gave correct result, multiply by sqrt(-1) if not:
   73|       |  */
   74|   135k|  fe25519_square(&chk, &r->x);
  ------------------
  |  |   18|   135k|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
   75|   135k|  fe25519_mul(&chk, &chk, &den);
  ------------------
  |  |   16|   135k|#define fe25519_mul            crypto_sign_ed25519_amd64_64_fe25519_mul
  ------------------
   76|   135k|  if (!fe25519_iseq_vartime(&chk, &num))
  ------------------
  |  |    9|   135k|#define fe25519_iseq_vartime   crypto_sign_ed25519_amd64_64_fe25519_iseq_vartime
  ------------------
  |  Branch (76:7): [True: 116k, False: 19.8k]
  ------------------
   77|   116k|    fe25519_mul(&r->x, &r->x, &sqrtm1);
  ------------------
  |  |   16|   116k|#define fe25519_mul            crypto_sign_ed25519_amd64_64_fe25519_mul
  ------------------
   78|       |
   79|       |  /* 4. Now we have one of the two square roots, except if input was not a square
   80|       |  */
   81|   135k|  fe25519_square(&chk, &r->x);
  ------------------
  |  |   18|   135k|#define fe25519_square         crypto_sign_ed25519_amd64_64_fe25519_square
  ------------------
   82|   135k|  fe25519_mul(&chk, &chk, &den);
  ------------------
  |  |   16|   135k|#define fe25519_mul            crypto_sign_ed25519_amd64_64_fe25519_mul
  ------------------
   83|   135k|  if (!fe25519_iseq_vartime(&chk, &num))
  ------------------
  |  |    9|   135k|#define fe25519_iseq_vartime   crypto_sign_ed25519_amd64_64_fe25519_iseq_vartime
  ------------------
  |  Branch (83:7): [True: 42.2k, False: 93.6k]
  ------------------
   84|  42.2k|    return -1;
   85|       |
   86|       |  /* 5. Choose the desired square root according to parity:
   87|       |  */
   88|  93.6k|  if(fe25519_getparity(&r->x) == (1-par)) // only change from original function was `!=` -> `==`
  ------------------
  |  |   13|  93.6k|#define fe25519_getparity      crypto_sign_ed25519_amd64_64_fe25519_getparity
  ------------------
  |  Branch (88:6): [True: 23.8k, False: 69.8k]
  ------------------
   89|  23.8k|    fe25519_neg(&r->x, &r->x);
  ------------------
  |  |   12|  23.8k|#define fe25519_neg            crypto_sign_ed25519_amd64_64_fe25519_neg
  ------------------
   90|       |
   91|  93.6k|  fe25519_mul(&r->t, &r->x, &r->y);
  ------------------
  |  |   16|  93.6k|#define fe25519_mul            crypto_sign_ed25519_amd64_64_fe25519_mul
  ------------------
   92|  93.6k|  return 0;
   93|   135k|}
amd64-64-24k.c:base_precomp:
  149|  87.3k|{
  150|  87.3k|  ge25519_p1p1 tp1p1;
  151|       |
  152|  87.3k|  p3_to_pniels(&base[0], r);
  153|   698k|  for (int i = 0; i < 7; ++i)
  ------------------
  |  Branch (153:19): [True: 611k, False: 87.3k]
  ------------------
  154|   611k|  {
  155|   611k|    ge25519_pnielsadd_p1p1(&tp1p1, r, &base[i]);
  ------------------
  |  |   24|   611k|#define ge25519_pnielsadd_p1p1            crypto_sign_ed25519_amd64_64_ge25519_pnielsadd_p1p1
  ------------------
  156|   611k|    ge25519_p1p1_to_pniels(&base[i + 1], &tp1p1);
  157|   611k|  }
  158|  87.3k|}
amd64-64-24k.c:p3_to_pniels:
   96|  87.3k|{
   97|  87.3k|  fe25519_sub(&out->ysubx, &src->y, &src->x);
  ------------------
  |  |   15|  87.3k|#define fe25519_sub            crypto_sign_ed25519_amd64_64_fe25519_sub
  ------------------
   98|  87.3k|  fe25519_add(&out->xaddy, &src->x, &src->y);
  ------------------
  |  |   14|  87.3k|#define fe25519_add            crypto_sign_ed25519_amd64_64_fe25519_add
  ------------------
   99|  87.3k|  fe25519_mul(&out->t2d, &src->t, &ec2d);
  ------------------
  |  |   16|  87.3k|#define fe25519_mul            crypto_sign_ed25519_amd64_64_fe25519_mul
  ------------------
  100|  87.3k|  out->z = src->z;
  101|  87.3k|}
amd64-64-24k.c:scalarmult_p1p1:
  111|  87.3k|{
  112|  87.3k|  signed char b[64];
  113|  87.3k|  ge25519_pniels t;
  114|  87.3k|  ge25519_p3 tp3;
  ------------------
  |  |   27|  87.3k|#define ge25519_p3 ge25519
  |  |  ------------------
  |  |  |  |    7|  87.3k|#define ge25519                           crypto_sign_ed25519_amd64_64_ge25519
  |  |  ------------------
  ------------------
  115|       |
  116|  87.3k|  sc25519 s;
  ------------------
  |  |    4|  87.3k|#define sc25519                  crypto_sign_ed25519_amd64_64_sc25519
  ------------------
  117|  87.3k|  memcpy(s.v, sec, sizeof(s));
  118|  87.3k|  sc25519_window4(b, &s);
  ------------------
  |  |   18|  87.3k|#define sc25519_window4          crypto_sign_ed25519_amd64_64_sc25519_window4
  ------------------
  119|       |
  120|       |  // set neutral
  121|  87.3k|  fe25519_setint(&tp3.x, 0);
  ------------------
  |  |   11|  87.3k|#define fe25519_setint         crypto_sign_ed25519_amd64_64_fe25519_setint
  ------------------
  122|  87.3k|  fe25519_setint(&tp3.y, 1);
  ------------------
  |  |   11|  87.3k|#define fe25519_setint         crypto_sign_ed25519_amd64_64_fe25519_setint
  ------------------
  123|  87.3k|  fe25519_setint(&tp3.t, 0);
  ------------------
  |  |   11|  87.3k|#define fe25519_setint         crypto_sign_ed25519_amd64_64_fe25519_setint
  ------------------
  124|  87.3k|  fe25519_setint(&tp3.z, 1);
  ------------------
  |  |   11|  87.3k|#define fe25519_setint         crypto_sign_ed25519_amd64_64_fe25519_setint
  ------------------
  125|       |  // end set neutral
  126|       |
  127|  5.50M|  for (int i = 63; /* break below*/ ; --i)
  128|  5.58M|  {
  129|  5.58M|    choose_tp(&t, (unsigned long long) 0, (signed long long) b[i], base);
  ------------------
  |  |   59|  5.58M|#define choose_tp crypto_sign_ed25519_amd64_64_choose_tp
  ------------------
  130|  5.58M|    ge25519_pnielsadd_p1p1(r, &tp3, &t);
  ------------------
  |  |   24|  5.58M|#define ge25519_pnielsadd_p1p1            crypto_sign_ed25519_amd64_64_ge25519_pnielsadd_p1p1
  ------------------
  131|       |
  132|  5.58M|    if (i == 0) break;
  ------------------
  |  Branch (132:9): [True: 87.3k, False: 5.50M]
  ------------------
  133|       |
  134|  5.50M|    ge25519_p1p1_to_p2((ge25519_p2*)&tp3, r);
  ------------------
  |  |   17|  5.50M|#define ge25519_p1p1_to_p2                crypto_sign_ed25519_amd64_64_ge25519_p1p1_to_p2
  ------------------
  135|       |
  136|  5.50M|    ge25519_dbl_p1p1(r,(ge25519_p2 *)&tp3);
  ------------------
  |  |   20|  5.50M|#define ge25519_dbl_p1p1                  crypto_sign_ed25519_amd64_64_ge25519_dbl_p1p1
  ------------------
  137|  5.50M|    ge25519_p1p1_to_p2((ge25519_p2 *)&tp3, r);
  ------------------
  |  |   17|  5.50M|#define ge25519_p1p1_to_p2                crypto_sign_ed25519_amd64_64_ge25519_p1p1_to_p2
  ------------------
  138|  5.50M|    ge25519_dbl_p1p1(r,(ge25519_p2 *)&tp3);
  ------------------
  |  |   20|  5.50M|#define ge25519_dbl_p1p1                  crypto_sign_ed25519_amd64_64_ge25519_dbl_p1p1
  ------------------
  139|  5.50M|    ge25519_p1p1_to_p2((ge25519_p2 *)&tp3, r);
  ------------------
  |  |   17|  5.50M|#define ge25519_p1p1_to_p2                crypto_sign_ed25519_amd64_64_ge25519_p1p1_to_p2
  ------------------
  140|  5.50M|    ge25519_dbl_p1p1(r,(ge25519_p2 *)&tp3);
  ------------------
  |  |   20|  5.50M|#define ge25519_dbl_p1p1                  crypto_sign_ed25519_amd64_64_ge25519_dbl_p1p1
  ------------------
  141|  5.50M|    ge25519_p1p1_to_p2((ge25519_p2 *)&tp3, r);
  ------------------
  |  |   17|  5.50M|#define ge25519_p1p1_to_p2                crypto_sign_ed25519_amd64_64_ge25519_p1p1_to_p2
  ------------------
  142|  5.50M|    ge25519_dbl_p1p1(r,(ge25519_p2 *)&tp3);
  ------------------
  |  |   20|  5.50M|#define ge25519_dbl_p1p1                  crypto_sign_ed25519_amd64_64_ge25519_dbl_p1p1
  ------------------
  143|  5.50M|    ge25519_p1p1_to_p3(&tp3, r);
  ------------------
  |  |   18|  5.50M|#define ge25519_p1p1_to_p3                crypto_sign_ed25519_amd64_64_ge25519_p1p1_to_p3
  ------------------
  144|  5.50M|  }
  145|  87.3k|}
amd64-64-24k.c:generate_key_derivation:
  177|   125k|{
  178|   125k|  ge25519 unpacked;
  ------------------
  |  |    7|   125k|#define ge25519                           crypto_sign_ed25519_amd64_64_ge25519
  ------------------
  179|   125k|  ge25519_pniels base[8];
  180|   125k|  ge25519_p1p1 tp1p1;
  181|   125k|  if (unpack_vartime(&unpacked, (unsigned char const*)tx_pub) != 0)
  ------------------
  |  Branch (181:7): [True: 38.6k, False: 87.3k]
  ------------------
  182|  38.6k|    return -1;
  183|       |
  184|  87.3k|  base_precomp(base, &unpacked);
  185|  87.3k|  scalarmult_p1p1(&tp1p1, base, view_sec);
  186|       |
  187|       |  // non-standard, monero specific - guarantees point is in ed25519 group
  188|  87.3k|  ge25519_p1p1_to_p2((ge25519_p2*)&unpacked, &tp1p1);
  ------------------
  |  |   17|  87.3k|#define ge25519_p1p1_to_p2                crypto_sign_ed25519_amd64_64_ge25519_p1p1_to_p2
  ------------------
  189|  87.3k|  ge25519_dbl_p1p1(&tp1p1,(ge25519_p2 *)&unpacked);
  ------------------
  |  |   20|  87.3k|#define ge25519_dbl_p1p1                  crypto_sign_ed25519_amd64_64_ge25519_dbl_p1p1
  ------------------
  190|  87.3k|  ge25519_p1p1_to_p2((ge25519_p2 *)&unpacked, &tp1p1);
  ------------------
  |  |   17|  87.3k|#define ge25519_p1p1_to_p2                crypto_sign_ed25519_amd64_64_ge25519_p1p1_to_p2
  ------------------
  191|  87.3k|  ge25519_dbl_p1p1(&tp1p1,(ge25519_p2 *)&unpacked);
  ------------------
  |  |   20|  87.3k|#define ge25519_dbl_p1p1                  crypto_sign_ed25519_amd64_64_ge25519_dbl_p1p1
  ------------------
  192|  87.3k|  ge25519_p1p1_to_p2((ge25519_p2 *)&unpacked, &tp1p1);
  ------------------
  |  |   17|  87.3k|#define ge25519_p1p1_to_p2                crypto_sign_ed25519_amd64_64_ge25519_p1p1_to_p2
  ------------------
  193|  87.3k|  ge25519_dbl_p1p1(&tp1p1,(ge25519_p2 *)&unpacked);
  ------------------
  |  |   20|  87.3k|#define ge25519_dbl_p1p1                  crypto_sign_ed25519_amd64_64_ge25519_dbl_p1p1
  ------------------
  194|  87.3k|  ge25519_p1p1_to_p3(&unpacked, &tp1p1);
  ------------------
  |  |   18|  87.3k|#define ge25519_p1p1_to_p3                crypto_sign_ed25519_amd64_64_ge25519_p1p1_to_p3
  ------------------
  195|       |
  196|  87.3k|  ge25519_pack((unsigned char*)out, &unpacked);
  ------------------
  |  |   10|  87.3k|#define ge25519_pack                      crypto_sign_ed25519_amd64_64_pack
  ------------------
  197|  87.3k|  return 0;
  198|   125k|}
amd64-64-24k.c:generate_subaddress_public_key:
  213|  9.97k|{
  214|  9.97k|  ge25519 p;
  ------------------
  |  |    7|  9.97k|#define ge25519                           crypto_sign_ed25519_amd64_64_ge25519
  ------------------
  215|  9.97k|  if (unpack_vartime(&p, (unsigned char const*)output_pub) != 0)
  ------------------
  |  Branch (215:7): [True: 3.64k, False: 6.32k]
  ------------------
  216|  3.64k|    return -1;
  217|       |
  218|  6.32k|  generate_subaddress_public_key_base(out, &p, special_sec);
  219|  6.32k|  return 0;
  220|  9.97k|}
amd64-64-24k.c:generate_subaddress_public_key_base:
  201|  6.32k|{
  202|  6.32k|  ge25519 p1;
  ------------------
  |  |    7|  6.32k|#define ge25519                           crypto_sign_ed25519_amd64_64_ge25519
  ------------------
  203|  6.32k|  sc25519 p2;
  ------------------
  |  |    4|  6.32k|#define sc25519                  crypto_sign_ed25519_amd64_64_sc25519
  ------------------
  204|       |
  205|  6.32k|  memcpy(p2.v, special_sec, sizeof(p2.v));
  206|  6.32k|  ge25519_scalarmult_base(&p1, &p2);
  ------------------
  |  |   16|  6.32k|#define ge25519_scalarmult_base           crypto_sign_ed25519_amd64_64_scalarmult_base
  ------------------
  207|  6.32k|  negate(&p1); // ge25519_sub is not provided by these libraries
  208|  6.32k|  ge25519_add(&p1, output_pub, &p1);
  ------------------
  |  |   12|  6.32k|#define ge25519_add                       crypto_sign_ed25519_amd64_64_ge25519_add
  ------------------
  209|  6.32k|  ge25519_pack((unsigned char*)out, &p1);
  ------------------
  |  |   10|  6.32k|#define ge25519_pack                      crypto_sign_ed25519_amd64_64_pack
  ------------------
  210|  6.32k|}
amd64-64-24k.c:negate:
  104|  6.32k|{
  105|  6.32k|  fe25519_neg(&out->x, &out->x);
  ------------------
  |  |   12|  6.32k|#define fe25519_neg            crypto_sign_ed25519_amd64_64_fe25519_neg
  ------------------
  106|  6.32k|  fe25519_neg(&out->t, &out->t);
  ------------------
  |  |   12|  6.32k|#define fe25519_neg            crypto_sign_ed25519_amd64_64_fe25519_neg
  ------------------
  107|  6.32k|}

_ZN10cryptonote11checkpointsC2Ev:
   74|      1|  {
   75|      1|  }
_ZN10cryptonote11checkpoints14add_checkpointEmRKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_:
   78|     54|  {
   79|     54|    crypto::hash h = crypto::null_hash;
   80|     54|    bool r = epee::string_tools::hex_to_pod(hash_str, h);
   81|     54|    CHECK_AND_ASSERT_MES(r, false, "Failed to parse checkpoint hash string into binary representation!");
  ------------------
  |  |  183|     54|#define CHECK_AND_ASSERT_MES(expr, fail_ret_val, message)   do{if(!(expr)) {LOG_ERROR(message); return fail_ret_val;};}while(0)
  |  |  ------------------
  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (183:67): [True: 0, False: 54]
  |  |  |  Branch (183:126): [Folded - Ignored]
  |  |  ------------------
  ------------------
   82|       |
   83|       |    // return false if adding at a height we already have AND the hash is different
   84|     54|    if (m_points.count(height))
  ------------------
  |  Branch (84:9): [True: 0, False: 54]
  ------------------
   85|      0|    {
   86|      0|      CHECK_AND_ASSERT_MES(h == m_points[height], false, "Checkpoint at given height already exists, and hash for new checkpoint was different!");
  ------------------
  |  |  183|      0|#define CHECK_AND_ASSERT_MES(expr, fail_ret_val, message)   do{if(!(expr)) {LOG_ERROR(message); return fail_ret_val;};}while(0)
  |  |  ------------------
  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (183:67): [True: 0, False: 0]
  |  |  |  Branch (183:126): [Folded - Ignored]
  |  |  ------------------
  ------------------
   87|      0|    }
   88|     54|    m_points[height] = h;
   89|     54|    if (!difficulty_str.empty())
  ------------------
  |  Branch (89:9): [True: 54, False: 0]
  ------------------
   90|     54|    {
   91|     54|      try
   92|     54|      {
   93|     54|        difficulty_type difficulty(difficulty_str);
   94|     54|        if (m_difficulty_points.count(height))
  ------------------
  |  Branch (94:13): [True: 0, False: 54]
  ------------------
   95|      0|        {
   96|      0|          CHECK_AND_ASSERT_MES(difficulty == m_difficulty_points[height], false, "Difficulty checkpoint at given height already exists, and difficulty for new checkpoint was different!");
  ------------------
  |  |  183|      0|#define CHECK_AND_ASSERT_MES(expr, fail_ret_val, message)   do{if(!(expr)) {LOG_ERROR(message); return fail_ret_val;};}while(0)
  |  |  ------------------
  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (183:67): [True: 0, False: 0]
  |  |  |  Branch (183:126): [Folded - Ignored]
  |  |  ------------------
  ------------------
   97|      0|        }
   98|     54|        m_difficulty_points[height] = difficulty;
   99|     54|      }
  100|     54|      catch (...)
  101|     54|      {
  102|      0|        LOG_ERROR("Failed to parse difficulty checkpoint: " << difficulty_str);
  ------------------
  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  ------------------
  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  103|      0|        return false;
  104|      0|      }
  105|     54|    }
  106|     54|    return true;
  107|     54|  }
_ZN10cryptonote11checkpoints24init_default_checkpointsENS_12network_typeE:
  184|      1|  {
  185|      1|    if (nettype == TESTNET)
  ------------------
  |  Branch (185:9): [True: 0, False: 1]
  ------------------
  186|      0|    {
  187|      0|      ADD_CHECKPOINT2(0,     "48ca7cd3c8de5b6a4d53d2861fbdaedca141553559f9be9520068053cda8430b", "0x1");
  ------------------
  |  |   39|      0|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      0|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 0]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  188|      0|      ADD_CHECKPOINT2(1000000, "46b690b710a07ea051bc4a6b6842ac37be691089c0f7758cfeec4d5fc0b4a258", "0x7aaad7153");
  ------------------
  |  |   39|      0|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      0|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 0]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  189|      0|      ADD_CHECKPOINT2(1058600, "12904f6b4d9e60fd875674e07147d2c83d6716253f046af7b894c3e81da7e1bd", "0x971efd119");
  ------------------
  |  |   39|      0|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      0|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 0]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  190|      0|      ADD_CHECKPOINT2(1450000, "87562ca6786f41556b8d5b48067303a57dc5ca77155b35199aedaeca1550f5a0", "0xa639e2930e");
  ------------------
  |  |   39|      0|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      0|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 0]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  191|      0|      return true;
  192|      0|    }
  193|      1|    if (nettype == STAGENET)
  ------------------
  |  Branch (193:9): [True: 0, False: 1]
  ------------------
  194|      0|    {
  195|      0|      ADD_CHECKPOINT2(0,       "76ee3cc98646292206cd3e86f74d88b4dcc1d937088645e9b0cbca84b7ce74eb", "0x1");
  ------------------
  |  |   39|      0|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      0|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 0]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  196|      0|      ADD_CHECKPOINT2(10000,   "1f8b0ce313f8b9ba9a46108bfd285c45ad7c2176871fd41c3a690d4830ce2fd5", "0x1d73ba");
  ------------------
  |  |   39|      0|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      0|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 0]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  197|      0|      ADD_CHECKPOINT2(550000,  "409f68cddd8e74b37469b41c1e61250d81c5776b42264f416d5d27c4626383ed", "0x5f3d4d03e");
  ------------------
  |  |   39|      0|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      0|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 0]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  198|      0|      return true;
  199|      0|    }
  200|      1|    ADD_CHECKPOINT2(1,     "771fbcd656ec1464d3a02ead5e18644030007a0fc664c0a964d30922821a8148", "0x2");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  201|      1|    ADD_CHECKPOINT2(10,    "c0e3b387e47042f72d8ccdca88071ff96bff1ac7cde09ae113dbb7ad3fe92381", "0x2a974");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  202|      1|    ADD_CHECKPOINT2(100,   "ac3e11ca545e57c49fca2b4e8c48c03c23be047c43e471e1394528b1f9f80b2d", "0x35d14b");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  203|      1|    ADD_CHECKPOINT2(1000,  "5acfc45acffd2b2e7345caf42fa02308c5793f15ec33946e969e829f40b03876", "0x36a0373");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  204|      1|    ADD_CHECKPOINT2(10000, "c758b7c81f928be3295d45e230646de8b852ec96a821eac3fea4daf3fcac0ca2", "0x60a91390");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  205|      1|    ADD_CHECKPOINT2(22231, "7cb10e29d67e1c069e6e11b17d30b809724255fee2f6868dc14cfc6ed44dfb25", "0x1e288793d");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  206|      1|    ADD_CHECKPOINT2(29556, "53c484a8ed91e4da621bb2fa88106dbde426fe90d7ef07b9c1e5127fb6f3a7f6", "0x71f64cce8");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  207|      1|    ADD_CHECKPOINT2(50000, "0fe8758ab06a8b9cb35b7328fd4f757af530a5d37759f9d3e421023231f7b31c", "0x893044b400");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  208|      1|    ADD_CHECKPOINT2(80000, "a62dcd7b536f22e003ebae8726e9e7276f63d594e264b6f0cd7aab27b66e75e3", "0x5cc113f1076");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  209|      1|    ADD_CHECKPOINT2(202612, "bbd604d2ba11ba27935e006ed39c9bfdd99b76bf4a50654bc1e1e61217962698", "0x73310a259eb2");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  210|      1|    ADD_CHECKPOINT2(202613, "e2aa337e78df1f98f462b3b1e560c6b914dec47b610698b7b7d1e3e86b6197c2", "0x733154039b97");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  211|      1|    ADD_CHECKPOINT2(202614, "c29e3dc37d8da3e72e506e31a213a58771b24450144305bcba9e70fa4d6ea6fb", "0x73319dc90cb6");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  212|      1|    ADD_CHECKPOINT2(205000, "5d3d7a26e6dc7535e34f03def711daa8c263785f73ec1fadef8a45880fde8063", "0x75fcc3d85123");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  213|      1|    ADD_CHECKPOINT2(220000, "9613f455933c00e3e33ac315cc6b455ee8aa0c567163836858c2d9caff111553", "0x89cfed0cae3c");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  214|      1|    ADD_CHECKPOINT2(230300, "bae7a80c46859db355556e3a9204a337ae8f24309926a1312323fdecf1920e61", "0x967d13e5baa9");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  215|      1|    ADD_CHECKPOINT2(230700, "93e631240ceac831da1aebfc5dac8f722c430463024763ebafa888796ceaeedf", "0x96fb9663ebe7");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  216|      1|    ADD_CHECKPOINT2(231350, "b5add137199b820e1ea26640e5c3e121fd85faa86a1e39cf7e6cc097bdeb1131", "0x97b9919177bf");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  217|      1|    ADD_CHECKPOINT2(232150, "955de8e6b6508af2c24f7334f97beeea651d78e9ade3ab18fec3763be3201aa8", "0x98a038b612e8");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  218|      1|    ADD_CHECKPOINT2(249380, "654fb0a81ce3e5caf7e3264a70f447d4bd07586c08fa50f6638cc54da0a52b2d", "0xac9739634e6d");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  219|      1|    ADD_CHECKPOINT2(460000, "75037a7aed3e765db96c75bcf908f59d690a5f3390baebb9edeafd336a1c4831", "0x167799549bdda");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  220|      1|    ADD_CHECKPOINT2(500000, "2428f0dbe49796be05ed81b347f53e1f7f44aed0abf641446ec2b94cae066b02", "0x188ce145e4ba9");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  221|      1|    ADD_CHECKPOINT2(600000, "f5828ebf7d7d1cb61762c4dfe3ccf4ecab2e1aad23e8113668d981713b7a54c5", "0x1d9f3759e1554");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  222|      1|    ADD_CHECKPOINT2(700000, "12be9b3d210b93f574d2526abb9c1ab2a881b479131fd0d4f7dac93875f503cd", "0x2201e4ee39c2c");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  223|      1|    ADD_CHECKPOINT2(825000, "56503f9ad766774b575be3aff73245e9d159be88132c93d1754764f28da2ff60", "0x27565a442d5df");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  224|      1|    ADD_CHECKPOINT2(900000, "d9958d0e7dcf91a5a7b11de225927bf7efc6eb26240315ce12372be902cc1337", "0x2a6334031546e");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  225|      1|    ADD_CHECKPOINT2(913193, "5292d5d56f6ba4de33a58d9a34d263e2cb3c6fee0aed2286fd4ac7f36d53c85f", "0x2aefe7f40f5ea");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  226|      1|    ADD_CHECKPOINT2(1000000, "a886ef5149902d8342475fee9bb296341b891ac67c4842f47a833f23c00ed721", "0x2edd71370f0e5");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  227|      1|    ADD_CHECKPOINT2(1100000, "3fd720c5c8b3072fc1ccda922dec1ef25f9ed88a1e6ad4103d0fe00b180a5903", "0x390eb0035c53a");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  228|      1|    ADD_CHECKPOINT2(1150000, "1dd16f626d18e1e988490dfd06de5920e22629c972c58b4d8daddea0038627b2", "0x422d5662e9e37");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  229|      1|    ADD_CHECKPOINT2(1200000, "fa7d13a90850882060479d100141ff84286599ae39c3277c8ea784393f882d1f", "0x4c73503fc4aa3");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  230|      1|    ADD_CHECKPOINT2(1300000, "31b34272343a44a9f4ac7de7a8fcf3b7d8a3124d7d6870affd510d2f37e74cd0", "0x723f49bc249d5");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  231|      1|    ADD_CHECKPOINT2(1390000, "a8f5649dd4ded60eedab475f2bec8c934681c07e3cf640e9be0617554f13ff6c", "0xb4bba65e2841b");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  232|      1|    ADD_CHECKPOINT2(1450000, "ac94e8860093bc7c83e4e91215cba1d663421ecf4067a0ae609c3a8b52bcfac2", "0x11a4aabdca9511");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  233|      1|    ADD_CHECKPOINT2(1530000, "01759bce497ec38e63c78b1038892169203bb78f87e488172f6b854fcd63ba7e", "0x2819ce9f9e91e5");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  234|      1|    ADD_CHECKPOINT2(1579000, "7d0d7a2346373afd41ed1e744a939fc5d474a7dbaa257be5c6fff4009e789241", "0x357a590e7dda83");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  235|      1|    ADD_CHECKPOINT2(1668900, "ac2dcaf3d2f58ffcf8391639f0f1ebafcb8eac43c49479c7c37f611868d07568", "0x474226e475cc3b");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  236|      1|    ADD_CHECKPOINT2(1775600, "1c6e01c661dc22cab939e79ec6a5272190624ce8356d2f7b958e4f9a57fdb05e", "0x5e3b9d206a27c6");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  237|      1|    ADD_CHECKPOINT2(1856000, "9b57f17f29c71a3acd8a7904b93c41fa6eb8d2b7c73936ce4f1702d14880ba29", "0x6bde5e1caccee1");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  238|      1|    ADD_CHECKPOINT2(1958000, "98a5d6e51afdf3146e0eefb10a66e8648d8d4d5c2742be8835e976ba217c9bb2", "0x79dd46d2a0971a");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  239|      1|    ADD_CHECKPOINT2(2046000, "5e867f0b8baefed9244a681df97fc885d8ab36c3dfcd24c7a3abf3b8ac8b8314", "0x9cb8b6ff2978c6");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  240|      1|    ADD_CHECKPOINT2(2092500, "c4e00820c9c7989b49153d5e90ae095a18a11d990e82fcc3be54e6ed785472b5", "0xb4e585a31369cb");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  241|      1|    ADD_CHECKPOINT2(2182500, "0d22b5f81982eff21d094af9e821dc2007e6342069e3b1a37b15d97646353124", "0xead4a874083492");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  242|      1|    ADD_CHECKPOINT2(2661600, "41c9060e8426012238e8a26da26fcb90797436896cc70886a894c2c560bcccf2", "0x2e0d87526ff161f");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  243|      1|    ADD_CHECKPOINT2(2677000, "1b9fee6246eeb176bd17d637bf252e9af54a4218675f01b4449cc0901867f9eb", "0x2f165bc1a5163ba");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  244|      1|    ADD_CHECKPOINT2(2706000, "d8eb144c5e1fe6b329ecc900ec95e7792fccff84175fb23a25ed59d7299a511c", "0x310f7d89372f705");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  245|      1|    ADD_CHECKPOINT2(2720000, "b19fb41dff15bd1016afbee9f8469f05aab715c9e5d1b974466a11fd58ecbb86", "0x3216b5851ddbb61");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  246|      1|    ADD_CHECKPOINT2(2817000, "39726d19ccaac01d150bec827b877ffae710b516bd633503662036ef4422e577", "0x3900669561954c1");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  247|      1|    ADD_CHECKPOINT2(2844000, "28fc7b446dfef5b469f5778eb72ddf32a307a5f5a9823d1c394e772349e05d40", "0x3af384ec0e97d12");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  248|      1|    ADD_CHECKPOINT2(2851000, "5bf0e47fc782263191a33f63a67db6c711781dc2a3c442e17ed901ec401be5c9", "0x3b6cd8a8ed610e8");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  249|      1|    ADD_CHECKPOINT2(2971000, "3d4cac5ac515eeabd18769ab943af85f36db51d28720def0d0e6effc2c8f5ce3", "0x436e532738b8b5b");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  250|      1|    ADD_CHECKPOINT2(2985000, "08f5e6b7301c1b6ed88268a28f8677a06e8ff943b3f9e48d3080f71f9c134bfb", "0x444b7b42a633c96");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  251|      1|    ADD_CHECKPOINT2(3088000, "bddf8ca09110d33d6d497f13a113630c2b6af1c84d4f3a6f35cb1446f2604ade", "0x4aed3615c2f8c3e");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  252|      1|    ADD_CHECKPOINT2(3102800, "083f4a34f9490403b564286e7f13fd1ed45c52c86fa47195f151594e5bc87504", "0x4bbed52d4da5dfb");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  253|      1|    ADD_CHECKPOINT2(3198000, "1d685b39be51e4e84e0af69fa78e023c7cb21de7d33acd012d0371d5f78712d5", "0x517d415fee3a816");
  ------------------
  |  |   39|      1|#define ADD_CHECKPOINT2(h, hash, difficulty)  CHECK_AND_ASSERT(add_checkpoint(h,  hash, difficulty), false);
  |  |  ------------------
  |  |  |  |  179|      1|#define CHECK_AND_ASSERT(expr, fail_ret_val)   do{if(!(expr)){LOCAL_ASSERT(expr); return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:54): [True: 0, False: 1]
  |  |  |  |  |  Branch (179:112): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  254|      1|    return true;
  255|      1|  }

base58.cpp:_ZN5tools6base5812_GLOBAL__N_116reverse_alphabetC2Ev:
   57|      2|        {
   58|      2|          m_data.resize(alphabet[alphabet_size - 1] - alphabet[0] + 1, -1);
   59|       |
   60|    118|          for (size_t i = 0; i < alphabet_size; ++i)
  ------------------
  |  Branch (60:30): [True: 116, False: 2]
  ------------------
   61|    116|          {
   62|    116|            size_t idx = static_cast<size_t>(alphabet[i] - alphabet[0]);
   63|    116|            m_data[idx] = static_cast<int8_t>(i);
   64|    116|          }
   65|      2|        }
base58.cpp:_ZN5tools6base5812_GLOBAL__N_119decoded_block_sizesC2Ev:
   84|      2|        {
   85|      2|          m_data.resize(encoded_block_sizes[full_block_size] + 1, -1);
   86|     20|          for (size_t i = 0; i <= full_block_size; ++i)
  ------------------
  |  Branch (86:30): [True: 18, False: 2]
  ------------------
   87|     18|          {
   88|     18|            m_data[encoded_block_sizes[i]] = static_cast<int>(i);
   89|     18|          }
   90|      2|        }

_Z14i18n_translatePKcRKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  326|      1|{
  327|      1|  const std::string key = context + std::string("", 1) + s;
  328|      1|  std::map<std::string,std::string>::const_iterator i = i18n_entries.find(key);
  329|      1|  if (i == i18n_entries.end())
  ------------------
  |  Branch (329:7): [True: 1, False: 0]
  ------------------
  330|      1|    return s;
  331|      0|  return (*i).second.c_str();
  332|      1|}

_ZN5tools14get_tick_countEv:
   46|  4.18k|  {
   47|  4.18k|#if defined(__x86_64__)
   48|  4.18k|    uint32_t hi, lo;
   49|  4.18k|    __asm__ volatile("rdtsc" : "=a"(lo), "=d"(hi));
   50|  4.18k|    return (((uint64_t)hi) << 32) | (uint64_t)lo;
   51|       |#else
   52|       |    return epee::misc_utils::get_ns_count();
   53|       |#endif
   54|  4.18k|  }
_ZN5tools16get_ticks_per_nsEv:
   58|      2|  {
   59|      2|    uint64_t t0 = epee::misc_utils::get_ns_count(), t1;
   60|      2|    uint64_t r0 = get_tick_count();
   61|       |
   62|  5.79M|    while (1)
  ------------------
  |  Branch (62:12): [Folded - Ignored]
  ------------------
   63|  5.79M|    {
   64|  5.79M|      t1 = epee::misc_utils::get_ns_count();
   65|  5.79M|      if (t1 - t0 > 1*100000000) break; // work 0.1 seconds
  ------------------
  |  Branch (65:11): [True: 2, False: 5.79M]
  ------------------
   66|  5.79M|    }
   67|       |
   68|      2|    uint64_t r1 = get_tick_count();
   69|      2|    uint64_t tpns256 = 256 * (r1 - r0) / (t1 - t0);
   70|      2|    return tpns256 ? tpns256 : 1;
  ------------------
  |  Branch (70:12): [True: 2, False: 0]
  ------------------
   71|      2|  }
_ZN5tools16PerformanceTimerC2Eb:
  106|  2.08k|PerformanceTimer::PerformanceTimer(bool paused): started(true), paused(paused)
  107|  2.08k|{
  108|  2.08k|  if (paused)
  ------------------
  |  Branch (108:7): [True: 0, False: 2.08k]
  ------------------
  109|      0|    ticks = 0;
  110|  2.08k|  else
  111|  2.08k|    ticks = get_tick_count();
  112|  2.08k|}
_ZN5tools23LoggingPerformanceTimerC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_mN2el5LevelE:
  114|  2.08k|LoggingPerformanceTimer::LoggingPerformanceTimer(const std::string &s, const std::string &cat, uint64_t unit, el::Level l): PerformanceTimer(), name(s), cat(cat), unit(unit), level(l)
  115|  2.08k|{
  116|  2.08k|  const bool log = ELPP->vRegistry()->allowed(level, cat.c_str());
  ------------------
  |  | 2792|  2.08k|#define ELPP el::base::Storage::getELPP()
  ------------------
  117|  2.08k|  if (!performance_timers)
  ------------------
  |  Branch (117:7): [True: 2.08k, False: 0]
  ------------------
  118|  2.08k|  {
  119|  2.08k|    if (log)
  ------------------
  |  Branch (119:9): [True: 0, False: 2.08k]
  ------------------
  120|      0|      PERF_LOG_ALWAYS(level, cat.c_str(), "PERF             ----------");
  ------------------
  |  |   37|      0|  el::base::Writer(level, el::Color::Default, __FILE__, __LINE__, ELPP_FUNC, el::base::DispatchAction::FileOnlyLog).construct(cat) << x
  |  |  ------------------
  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  ------------------
  ------------------
  121|  2.08k|    performance_timers = new std::vector<LoggingPerformanceTimer*>();
  122|  2.08k|    performance_timers->reserve(16); // how deep before realloc
  123|  2.08k|  }
  124|      0|  else
  125|      0|  {
  126|      0|    LoggingPerformanceTimer *pt = performance_timers->back();
  127|      0|    if (!pt->started && !pt->paused)
  ------------------
  |  Branch (127:9): [True: 0, False: 0]
  |  Branch (127:25): [True: 0, False: 0]
  ------------------
  128|      0|    {
  129|      0|      if (log)
  ------------------
  |  Branch (129:11): [True: 0, False: 0]
  ------------------
  130|      0|      {
  131|      0|        size_t size = 0; for (const auto *tmp: *performance_timers) if (!tmp->paused) ++size;
  ------------------
  |  Branch (131:46): [True: 0, False: 0]
  |  Branch (131:73): [True: 0, False: 0]
  ------------------
  132|      0|        PERF_LOG_ALWAYS(pt->level, cat.c_str(), "PERF           " << std::string((size-1) * 2, ' ') << "  " << pt->name);
  ------------------
  |  |   37|      0|  el::base::Writer(level, el::Color::Default, __FILE__, __LINE__, ELPP_FUNC, el::base::DispatchAction::FileOnlyLog).construct(cat) << x
  |  |  ------------------
  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  ------------------
  ------------------
  133|      0|      }
  134|      0|      pt->started = true;
  135|      0|    }
  136|      0|  }
  137|  2.08k|  performance_timers->push_back(this);
  138|  2.08k|}
_ZN5tools16PerformanceTimerD2Ev:
  141|  2.08k|{
  142|  2.08k|  if (!paused)
  ------------------
  |  Branch (142:7): [True: 0, False: 2.08k]
  ------------------
  143|      0|    ticks = get_tick_count() - ticks;
  144|  2.08k|}
_ZN5tools23LoggingPerformanceTimerD2Ev:
  147|  2.08k|{
  148|  2.08k|  pause();
  149|  2.08k|  performance_timers->pop_back();
  150|  2.08k|  const bool log = ELPP->vRegistry()->allowed(level, cat.c_str());
  ------------------
  |  | 2792|  2.08k|#define ELPP el::base::Storage::getELPP()
  ------------------
  151|  2.08k|  if (log)
  ------------------
  |  Branch (151:7): [True: 0, False: 2.08k]
  ------------------
  152|      0|  {
  153|      0|    char s[12];
  154|      0|    snprintf(s, sizeof(s), "%8llu  ", (unsigned long long)(ticks_to_ns(ticks) / (1000000000 / unit)));
  155|      0|    size_t size = 0; for (const auto *tmp: *performance_timers) if (!tmp->paused || tmp==this) ++size;
  ------------------
  |  Branch (155:42): [True: 0, False: 0]
  |  Branch (155:69): [True: 0, False: 0]
  |  Branch (155:85): [True: 0, False: 0]
  ------------------
  156|      0|    PERF_LOG_ALWAYS(level, cat.c_str(), "PERF " << s << std::string(size * 2, ' ') << "  " << name);
  ------------------
  |  |   37|      0|  el::base::Writer(level, el::Color::Default, __FILE__, __LINE__, ELPP_FUNC, el::base::DispatchAction::FileOnlyLog).construct(cat) << x
  |  |  ------------------
  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  ------------------
  ------------------
  157|      0|  }
  158|  2.08k|  if (performance_timers->empty())
  ------------------
  |  Branch (158:7): [True: 2.08k, False: 0]
  ------------------
  159|  2.08k|  {
  160|  2.08k|    delete performance_timers;
  161|  2.08k|    performance_timers = NULL;
  162|  2.08k|  }
  163|  2.08k|}
_ZN5tools16PerformanceTimer5pauseEv:
  166|  2.08k|{
  167|  2.08k|  if (paused)
  ------------------
  |  Branch (167:7): [True: 0, False: 2.08k]
  ------------------
  168|      0|    return;
  169|  2.08k|  ticks = get_tick_count() - ticks;
  170|  2.08k|  paused = true;
  171|  2.08k|}

_ZN5tools11read_varintIRPKhjEEiOT_S5_RT0_:
  125|   211k|    int read_varint(InputIt &&first, InputIt &&last, T &i) {
  126|   211k|    return read_varint<std::numeric_limits<T>::digits>(std::forward<InputIt>(first), std::forward<InputIt>(last), i);
  127|   211k|  }
_ZN5tools11read_varintILi32ERPKhjEENSt3__19enable_ifIXaaaaaasr3std11is_integralIT1_EE5valuesr3std11is_unsignedIS6_EE5valueleLi0ET_leT_sr3std14numeric_limitsIS6_EE6digitsEiE4typeEOT0_SA_RS6_:
   94|   211k|    read_varint(InputIt &&first, InputIt &&last, T &write) {
   95|   211k|    int read = 0;
   96|   211k|    write = 0;
   97|   270k|    for (int shift = 0;; shift += 7) {
   98|   270k|      if (first == last) {
  ------------------
  |  Branch (98:11): [True: 3.81k, False: 266k]
  ------------------
   99|  3.81k|	return read; 
  100|  3.81k|      }
  101|   266k|      unsigned char byte = *first;
  102|   266k|      ++first;
  103|   266k|      ++read;
  104|   266k|      if (shift + 7 >= bits && byte >= 1 << (bits - shift)) {
  ------------------
  |  Branch (104:11): [True: 8.46k, False: 258k]
  |  Branch (104:32): [True: 70, False: 8.39k]
  ------------------
  105|     70|	return EVARINT_OVERFLOW;
  106|     70|      }
  107|   266k|      if (byte == 0 && shift != 0) {
  ------------------
  |  Branch (107:11): [True: 41.1k, False: 225k]
  |  Branch (107:24): [True: 93, False: 41.0k]
  ------------------
  108|     93|	return EVARINT_REPRESENT;
  109|     93|      }
  110|       |
  111|   266k|      write |= static_cast<T>(byte & 0x7f) << shift; /* Does the actually placing into write, stripping the first bit */
  112|       |
  113|       |      /* If there is no next */
  114|   266k|      if ((byte & 0x80) == 0) {
  ------------------
  |  Branch (114:11): [True: 207k, False: 58.7k]
  ------------------
  115|   207k|	break;
  116|   207k|      }
  117|   266k|    }
  118|   207k|    return read;
  119|   211k|  }
_ZN5tools11read_varintIRPKhmEEiOT_S5_RT0_:
  125|   800k|    int read_varint(InputIt &&first, InputIt &&last, T &i) {
  126|   800k|    return read_varint<std::numeric_limits<T>::digits>(std::forward<InputIt>(first), std::forward<InputIt>(last), i);
  127|   800k|  }
_ZN5tools11read_varintILi64ERPKhmEENSt3__19enable_ifIXaaaaaasr3std11is_integralIT1_EE5valuesr3std11is_unsignedIS6_EE5valueleLi0ET_leT_sr3std14numeric_limitsIS6_EE6digitsEiE4typeEOT0_SA_RS6_:
   94|   800k|    read_varint(InputIt &&first, InputIt &&last, T &write) {
   95|   800k|    int read = 0;
   96|   800k|    write = 0;
   97|   950k|    for (int shift = 0;; shift += 7) {
   98|   950k|      if (first == last) {
  ------------------
  |  Branch (98:11): [True: 10.6k, False: 940k]
  ------------------
   99|  10.6k|	return read; 
  100|  10.6k|      }
  101|   940k|      unsigned char byte = *first;
  102|   940k|      ++first;
  103|   940k|      ++read;
  104|   940k|      if (shift + 7 >= bits && byte >= 1 << (bits - shift)) {
  ------------------
  |  Branch (104:11): [True: 2.97k, False: 937k]
  |  Branch (104:32): [True: 232, False: 2.74k]
  ------------------
  105|    232|	return EVARINT_OVERFLOW;
  106|    232|      }
  107|   939k|      if (byte == 0 && shift != 0) {
  ------------------
  |  Branch (107:11): [True: 369k, False: 570k]
  |  Branch (107:24): [True: 256, False: 369k]
  ------------------
  108|    256|	return EVARINT_REPRESENT;
  109|    256|      }
  110|       |
  111|   939k|      write |= static_cast<T>(byte & 0x7f) << shift; /* Does the actually placing into write, stripping the first bit */
  112|       |
  113|       |      /* If there is no next */
  114|   939k|      if ((byte & 0x80) == 0) {
  ------------------
  |  Branch (114:11): [True: 789k, False: 150k]
  ------------------
  115|   789k|	break;
  116|   789k|      }
  117|   939k|    }
  118|   789k|    return read;
  119|   800k|  }
_ZN5tools12write_varintINSt3__119ostreambuf_iteratorIcNS1_11char_traitsIcEEEEmEENS1_9enable_ifIXaasr3std11is_integralIT0_EE5valuesr3std11is_unsignedIS7_EE5valueEvE4typeEOT_S7_:
   69|  18.5k|  write_varint(OutputIt &&dest, T i) {
   70|       |    /* Make sure that there is one after this */
   71|  18.7k|    while (i >= 0x80) {
  ------------------
  |  Branch (71:12): [True: 190, False: 18.5k]
  ------------------
   72|    190|      *dest = (static_cast<char>(i) & 0x7f) | 0x80; 
   73|    190|      ++dest;
   74|    190|      i >>= 7;			/* I should be in multiples of 7, this should just get the next part */
   75|    190|    }
   76|       |    /* writes the last one to dest */
   77|  18.5k|    *dest = static_cast<char>(i);
   78|  18.5k|    dest++;			/* Seems kinda pointless... */
   79|  18.5k|  }
_ZN5tools12write_varintIRPcmEENSt3__19enable_ifIXaasr3std11is_integralIT0_EE5valuesr3std11is_unsignedIS5_EE5valueEvE4typeEOT_S5_:
   69|  11.0k|  write_varint(OutputIt &&dest, T i) {
   70|       |    /* Make sure that there is one after this */
   71|  18.7k|    while (i >= 0x80) {
  ------------------
  |  Branch (71:12): [True: 7.68k, False: 11.0k]
  ------------------
   72|  7.68k|      *dest = (static_cast<char>(i) & 0x7f) | 0x80; 
   73|  7.68k|      ++dest;
   74|  7.68k|      i >>= 7;			/* I should be in multiples of 7, this should just get the next part */
   75|  7.68k|    }
   76|       |    /* writes the last one to dest */
   77|  11.0k|    *dest = static_cast<char>(i);
   78|  11.0k|    dest++;			/* Seems kinda pointless... */
   79|  11.0k|  }
_ZN5tools12write_varintINSt3__119ostreambuf_iteratorIcNS1_11char_traitsIcEEEEjEENS1_9enable_ifIXaasr3std11is_integralIT0_EE5valuesr3std11is_unsignedIS7_EE5valueEvE4typeEOT_S7_:
   69|  5.59k|  write_varint(OutputIt &&dest, T i) {
   70|       |    /* Make sure that there is one after this */
   71|  5.59k|    while (i >= 0x80) {
  ------------------
  |  Branch (71:12): [True: 0, False: 5.59k]
  ------------------
   72|      0|      *dest = (static_cast<char>(i) & 0x7f) | 0x80; 
   73|      0|      ++dest;
   74|      0|      i >>= 7;			/* I should be in multiples of 7, this should just get the next part */
   75|      0|    }
   76|       |    /* writes the last one to dest */
   77|  5.59k|    *dest = static_cast<char>(i);
   78|  5.59k|    dest++;			/* Seems kinda pointless... */
   79|  5.59k|  }
_ZN5tools15get_varint_dataImEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKT_:
   85|      2|    {
   86|      2|      std::stringstream ss;
   87|      2|      write_varint(std::ostreambuf_iterator<char>(ss), v);
   88|      2|      return ss.str();
   89|      2|    }
_ZN5tools12write_varintINSt3__119ostreambuf_iteratorIcNS1_11char_traitsIcEEEEhEENS1_9enable_ifIXaasr3std11is_integralIT0_EE5valuesr3std11is_unsignedIS7_EE5valueEvE4typeEOT_S7_:
   69|      6|  write_varint(OutputIt &&dest, T i) {
   70|       |    /* Make sure that there is one after this */
   71|      6|    while (i >= 0x80) {
  ------------------
  |  Branch (71:12): [True: 0, False: 6]
  ------------------
   72|      0|      *dest = (static_cast<char>(i) & 0x7f) | 0x80; 
   73|      0|      ++dest;
   74|      0|      i >>= 7;			/* I should be in multiples of 7, this should just get the next part */
   75|      0|    }
   76|       |    /* writes the last one to dest */
   77|      6|    *dest = static_cast<char>(i);
   78|      6|    dest++;			/* Seems kinda pointless... */
   79|      6|  }

blake256_compress:
   83|      4|void blake256_compress(state *S, const uint8_t *block) {
   84|      4|    uint32_t v[16], m[16], i;
   85|       |
   86|      4|#define ROT(x,n) (((x)<<(32-n))|((x)>>(n)))
   87|      4|#define G(a,b,c,d,e)                                      \
   88|      4|    v[a] += (m[sigma[i][e]] ^ cst[sigma[i][e+1]]) + v[b]; \
   89|      4|    v[d] = ROT(v[d] ^ v[a],16);                           \
   90|      4|    v[c] += v[d];                                         \
   91|      4|    v[b] = ROT(v[b] ^ v[c],12);                           \
   92|      4|    v[a] += (m[sigma[i][e+1]] ^ cst[sigma[i][e]])+v[b];   \
   93|      4|    v[d] = ROT(v[d] ^ v[a], 8);                           \
   94|      4|    v[c] += v[d];                                         \
   95|      4|    v[b] = ROT(v[b] ^ v[c], 7);
   96|       |
   97|     68|    for (i = 0; i < 16; ++i) m[i] = U8TO32(block + i * 4);
  ------------------
  |  |   47|     64|    (((uint32_t)((p)[0]) << 24) | ((uint32_t)((p)[1]) << 16) |    \
  |  |   48|     64|     ((uint32_t)((p)[2]) <<  8) | ((uint32_t)((p)[3])      ))
  ------------------
  |  Branch (97:17): [True: 64, False: 4]
  ------------------
   98|     36|    for (i = 0; i < 8;  ++i) v[i] = S->h[i];
  ------------------
  |  Branch (98:17): [True: 32, False: 4]
  ------------------
   99|      4|    v[ 8] = S->s[0] ^ 0x243F6A88;
  100|      4|    v[ 9] = S->s[1] ^ 0x85A308D3;
  101|      4|    v[10] = S->s[2] ^ 0x13198A2E;
  102|      4|    v[11] = S->s[3] ^ 0x03707344;
  103|      4|    v[12] = 0xA4093822;
  104|      4|    v[13] = 0x299F31D0;
  105|      4|    v[14] = 0x082EFA98;
  106|      4|    v[15] = 0xEC4E6C89;
  107|       |
  108|      4|    if (S->nullt == 0) {
  ------------------
  |  Branch (108:9): [True: 4, False: 0]
  ------------------
  109|      4|        v[12] ^= S->t[0];
  110|      4|        v[13] ^= S->t[0];
  111|      4|        v[14] ^= S->t[1];
  112|      4|        v[15] ^= S->t[1];
  113|      4|    }
  114|       |
  115|     60|    for (i = 0; i < 14; ++i) {
  ------------------
  |  Branch (115:17): [True: 56, False: 4]
  ------------------
  116|     56|        G(0, 4,  8, 12,  0);
  ------------------
  |  |   88|     56|    v[a] += (m[sigma[i][e]] ^ cst[sigma[i][e+1]]) + v[b]; \
  |  |   89|     56|    v[d] = ROT(v[d] ^ v[a],16);                           \
  |  |  ------------------
  |  |  |  |   86|     56|#define ROT(x,n) (((x)<<(32-n))|((x)>>(n)))
  |  |  ------------------
  |  |   90|     56|    v[c] += v[d];                                         \
  |  |   91|     56|    v[b] = ROT(v[b] ^ v[c],12);                           \
  |  |  ------------------
  |  |  |  |   86|     56|#define ROT(x,n) (((x)<<(32-n))|((x)>>(n)))
  |  |  ------------------
  |  |   92|     56|    v[a] += (m[sigma[i][e+1]] ^ cst[sigma[i][e]])+v[b];   \
  |  |   93|     56|    v[d] = ROT(v[d] ^ v[a], 8);                           \
  |  |  ------------------
  |  |  |  |   86|     56|#define ROT(x,n) (((x)<<(32-n))|((x)>>(n)))
  |  |  ------------------
  |  |   94|     56|    v[c] += v[d];                                         \
  |  |   95|     56|    v[b] = ROT(v[b] ^ v[c], 7);
  |  |  ------------------
  |  |  |  |   86|     56|#define ROT(x,n) (((x)<<(32-n))|((x)>>(n)))
  |  |  ------------------
  ------------------
  117|     56|        G(1, 5,  9, 13,  2);
  ------------------
  |  |   88|     56|    v[a] += (m[sigma[i][e]] ^ cst[sigma[i][e+1]]) + v[b]; \
  |  |   89|     56|    v[d] = ROT(v[d] ^ v[a],16);                           \
  |  |  ------------------
  |  |  |  |   86|     56|#define ROT(x,n) (((x)<<(32-n))|((x)>>(n)))
  |  |  ------------------
  |  |   90|     56|    v[c] += v[d];                                         \
  |  |   91|     56|    v[b] = ROT(v[b] ^ v[c],12);                           \
  |  |  ------------------
  |  |  |  |   86|     56|#define ROT(x,n) (((x)<<(32-n))|((x)>>(n)))
  |  |  ------------------
  |  |   92|     56|    v[a] += (m[sigma[i][e+1]] ^ cst[sigma[i][e]])+v[b];   \
  |  |   93|     56|    v[d] = ROT(v[d] ^ v[a], 8);                           \
  |  |  ------------------
  |  |  |  |   86|     56|#define ROT(x,n) (((x)<<(32-n))|((x)>>(n)))
  |  |  ------------------
  |  |   94|     56|    v[c] += v[d];                                         \
  |  |   95|     56|    v[b] = ROT(v[b] ^ v[c], 7);
  |  |  ------------------
  |  |  |  |   86|     56|#define ROT(x,n) (((x)<<(32-n))|((x)>>(n)))
  |  |  ------------------
  ------------------
  118|     56|        G(2, 6, 10, 14,  4);
  ------------------
  |  |   88|     56|    v[a] += (m[sigma[i][e]] ^ cst[sigma[i][e+1]]) + v[b]; \
  |  |   89|     56|    v[d] = ROT(v[d] ^ v[a],16);                           \
  |  |  ------------------
  |  |  |  |   86|     56|#define ROT(x,n) (((x)<<(32-n))|((x)>>(n)))
  |  |  ------------------
  |  |   90|     56|    v[c] += v[d];                                         \
  |  |   91|     56|    v[b] = ROT(v[b] ^ v[c],12);                           \
  |  |  ------------------
  |  |  |  |   86|     56|#define ROT(x,n) (((x)<<(32-n))|((x)>>(n)))
  |  |  ------------------
  |  |   92|     56|    v[a] += (m[sigma[i][e+1]] ^ cst[sigma[i][e]])+v[b];   \
  |  |   93|     56|    v[d] = ROT(v[d] ^ v[a], 8);                           \
  |  |  ------------------
  |  |  |  |   86|     56|#define ROT(x,n) (((x)<<(32-n))|((x)>>(n)))
  |  |  ------------------
  |  |   94|     56|    v[c] += v[d];                                         \
  |  |   95|     56|    v[b] = ROT(v[b] ^ v[c], 7);
  |  |  ------------------
  |  |  |  |   86|     56|#define ROT(x,n) (((x)<<(32-n))|((x)>>(n)))
  |  |  ------------------
  ------------------
  119|     56|        G(3, 7, 11, 15,  6);
  ------------------
  |  |   88|     56|    v[a] += (m[sigma[i][e]] ^ cst[sigma[i][e+1]]) + v[b]; \
  |  |   89|     56|    v[d] = ROT(v[d] ^ v[a],16);                           \
  |  |  ------------------
  |  |  |  |   86|     56|#define ROT(x,n) (((x)<<(32-n))|((x)>>(n)))
  |  |  ------------------
  |  |   90|     56|    v[c] += v[d];                                         \
  |  |   91|     56|    v[b] = ROT(v[b] ^ v[c],12);                           \
  |  |  ------------------
  |  |  |  |   86|     56|#define ROT(x,n) (((x)<<(32-n))|((x)>>(n)))
  |  |  ------------------
  |  |   92|     56|    v[a] += (m[sigma[i][e+1]] ^ cst[sigma[i][e]])+v[b];   \
  |  |   93|     56|    v[d] = ROT(v[d] ^ v[a], 8);                           \
  |  |  ------------------
  |  |  |  |   86|     56|#define ROT(x,n) (((x)<<(32-n))|((x)>>(n)))
  |  |  ------------------
  |  |   94|     56|    v[c] += v[d];                                         \
  |  |   95|     56|    v[b] = ROT(v[b] ^ v[c], 7);
  |  |  ------------------
  |  |  |  |   86|     56|#define ROT(x,n) (((x)<<(32-n))|((x)>>(n)))
  |  |  ------------------
  ------------------
  120|     56|        G(3, 4,  9, 14, 14);
  ------------------
  |  |   88|     56|    v[a] += (m[sigma[i][e]] ^ cst[sigma[i][e+1]]) + v[b]; \
  |  |   89|     56|    v[d] = ROT(v[d] ^ v[a],16);                           \
  |  |  ------------------
  |  |  |  |   86|     56|#define ROT(x,n) (((x)<<(32-n))|((x)>>(n)))
  |  |  ------------------
  |  |   90|     56|    v[c] += v[d];                                         \
  |  |   91|     56|    v[b] = ROT(v[b] ^ v[c],12);                           \
  |  |  ------------------
  |  |  |  |   86|     56|#define ROT(x,n) (((x)<<(32-n))|((x)>>(n)))
  |  |  ------------------
  |  |   92|     56|    v[a] += (m[sigma[i][e+1]] ^ cst[sigma[i][e]])+v[b];   \
  |  |   93|     56|    v[d] = ROT(v[d] ^ v[a], 8);                           \
  |  |  ------------------
  |  |  |  |   86|     56|#define ROT(x,n) (((x)<<(32-n))|((x)>>(n)))
  |  |  ------------------
  |  |   94|     56|    v[c] += v[d];                                         \
  |  |   95|     56|    v[b] = ROT(v[b] ^ v[c], 7);
  |  |  ------------------
  |  |  |  |   86|     56|#define ROT(x,n) (((x)<<(32-n))|((x)>>(n)))
  |  |  ------------------
  ------------------
  121|     56|        G(2, 7,  8, 13, 12);
  ------------------
  |  |   88|     56|    v[a] += (m[sigma[i][e]] ^ cst[sigma[i][e+1]]) + v[b]; \
  |  |   89|     56|    v[d] = ROT(v[d] ^ v[a],16);                           \
  |  |  ------------------
  |  |  |  |   86|     56|#define ROT(x,n) (((x)<<(32-n))|((x)>>(n)))
  |  |  ------------------
  |  |   90|     56|    v[c] += v[d];                                         \
  |  |   91|     56|    v[b] = ROT(v[b] ^ v[c],12);                           \
  |  |  ------------------
  |  |  |  |   86|     56|#define ROT(x,n) (((x)<<(32-n))|((x)>>(n)))
  |  |  ------------------
  |  |   92|     56|    v[a] += (m[sigma[i][e+1]] ^ cst[sigma[i][e]])+v[b];   \
  |  |   93|     56|    v[d] = ROT(v[d] ^ v[a], 8);                           \
  |  |  ------------------
  |  |  |  |   86|     56|#define ROT(x,n) (((x)<<(32-n))|((x)>>(n)))
  |  |  ------------------
  |  |   94|     56|    v[c] += v[d];                                         \
  |  |   95|     56|    v[b] = ROT(v[b] ^ v[c], 7);
  |  |  ------------------
  |  |  |  |   86|     56|#define ROT(x,n) (((x)<<(32-n))|((x)>>(n)))
  |  |  ------------------
  ------------------
  122|     56|        G(0, 5, 10, 15,  8);
  ------------------
  |  |   88|     56|    v[a] += (m[sigma[i][e]] ^ cst[sigma[i][e+1]]) + v[b]; \
  |  |   89|     56|    v[d] = ROT(v[d] ^ v[a],16);                           \
  |  |  ------------------
  |  |  |  |   86|     56|#define ROT(x,n) (((x)<<(32-n))|((x)>>(n)))
  |  |  ------------------
  |  |   90|     56|    v[c] += v[d];                                         \
  |  |   91|     56|    v[b] = ROT(v[b] ^ v[c],12);                           \
  |  |  ------------------
  |  |  |  |   86|     56|#define ROT(x,n) (((x)<<(32-n))|((x)>>(n)))
  |  |  ------------------
  |  |   92|     56|    v[a] += (m[sigma[i][e+1]] ^ cst[sigma[i][e]])+v[b];   \
  |  |   93|     56|    v[d] = ROT(v[d] ^ v[a], 8);                           \
  |  |  ------------------
  |  |  |  |   86|     56|#define ROT(x,n) (((x)<<(32-n))|((x)>>(n)))
  |  |  ------------------
  |  |   94|     56|    v[c] += v[d];                                         \
  |  |   95|     56|    v[b] = ROT(v[b] ^ v[c], 7);
  |  |  ------------------
  |  |  |  |   86|     56|#define ROT(x,n) (((x)<<(32-n))|((x)>>(n)))
  |  |  ------------------
  ------------------
  123|     56|        G(1, 6, 11, 12, 10);
  ------------------
  |  |   88|     56|    v[a] += (m[sigma[i][e]] ^ cst[sigma[i][e+1]]) + v[b]; \
  |  |   89|     56|    v[d] = ROT(v[d] ^ v[a],16);                           \
  |  |  ------------------
  |  |  |  |   86|     56|#define ROT(x,n) (((x)<<(32-n))|((x)>>(n)))
  |  |  ------------------
  |  |   90|     56|    v[c] += v[d];                                         \
  |  |   91|     56|    v[b] = ROT(v[b] ^ v[c],12);                           \
  |  |  ------------------
  |  |  |  |   86|     56|#define ROT(x,n) (((x)<<(32-n))|((x)>>(n)))
  |  |  ------------------
  |  |   92|     56|    v[a] += (m[sigma[i][e+1]] ^ cst[sigma[i][e]])+v[b];   \
  |  |   93|     56|    v[d] = ROT(v[d] ^ v[a], 8);                           \
  |  |  ------------------
  |  |  |  |   86|     56|#define ROT(x,n) (((x)<<(32-n))|((x)>>(n)))
  |  |  ------------------
  |  |   94|     56|    v[c] += v[d];                                         \
  |  |   95|     56|    v[b] = ROT(v[b] ^ v[c], 7);
  |  |  ------------------
  |  |  |  |   86|     56|#define ROT(x,n) (((x)<<(32-n))|((x)>>(n)))
  |  |  ------------------
  ------------------
  124|     56|    }
  125|       |
  126|     68|    for (i = 0; i < 16; ++i) S->h[i % 8] ^= v[i];
  ------------------
  |  Branch (126:17): [True: 64, False: 4]
  ------------------
  127|     36|    for (i = 0; i < 8;  ++i) S->h[i] ^= S->s[i % 4];
  ------------------
  |  Branch (127:17): [True: 32, False: 4]
  ------------------
  128|      4|}
blake256_init:
  130|      1|void blake256_init(state *S) {
  131|      1|    S->h[0] = 0x6A09E667;
  132|      1|    S->h[1] = 0xBB67AE85;
  133|      1|    S->h[2] = 0x3C6EF372;
  134|      1|    S->h[3] = 0xA54FF53A;
  135|      1|    S->h[4] = 0x510E527F;
  136|      1|    S->h[5] = 0x9B05688C;
  137|      1|    S->h[6] = 0x1F83D9AB;
  138|      1|    S->h[7] = 0x5BE0CD19;
  139|      1|    S->t[0] = S->t[1] = S->buflen = S->nullt = 0;
  140|      1|    S->s[0] = S->s[1] = S->s[2] = S->s[3] = 0;
  141|      1|}
blake256_update:
  157|      4|void blake256_update(state *S, const uint8_t *data, uint64_t datalen) {
  158|      4|    int left = S->buflen >> 3;
  159|      4|    int fill = 64 - left;
  160|       |
  161|      4|    if (left && (((datalen >> 3)) >= (unsigned) fill)) {
  ------------------
  |  Branch (161:9): [True: 3, False: 1]
  |  Branch (161:17): [True: 1, False: 2]
  ------------------
  162|      1|        memcpy((void *) (S->buf + left), (void *) data, fill);
  163|      1|        S->t[0] += 512;
  164|      1|        if (S->t[0] == 0) S->t[1]++;
  ------------------
  |  Branch (164:13): [True: 0, False: 1]
  ------------------
  165|      1|        blake256_compress(S, S->buf);
  166|      1|        data += fill;
  167|      1|        datalen -= (fill << 3);
  168|      1|        left = 0;
  169|      1|    }
  170|       |
  171|      7|    while (datalen >= 512) {
  ------------------
  |  Branch (171:12): [True: 3, False: 4]
  ------------------
  172|      3|        S->t[0] += 512;
  173|      3|        if (S->t[0] == 0) S->t[1]++;
  ------------------
  |  Branch (173:13): [True: 0, False: 3]
  ------------------
  174|      3|        blake256_compress(S, data);
  175|      3|        data += 64;
  176|      3|        datalen -= 512;
  177|      3|    }
  178|       |
  179|      4|    if (datalen > 0) {
  ------------------
  |  Branch (179:9): [True: 3, False: 1]
  ------------------
  180|      3|        memcpy((void *) (S->buf + left), (void *) data, datalen >> 3);
  181|      3|        S->buflen = (left << 3) + datalen;
  182|      3|    } else {
  183|      1|        S->buflen = 0;
  184|      1|    }
  185|      4|}
blake256_final_h:
  192|      1|void blake256_final_h(state *S, uint8_t *digest, uint8_t pa, uint8_t pb) {
  193|      1|    uint8_t msglen[8];
  194|      1|    uint32_t lo = S->t[0] + S->buflen, hi = S->t[1];
  195|      1|    if (lo < (unsigned) S->buflen) hi++;
  ------------------
  |  Branch (195:9): [True: 0, False: 1]
  ------------------
  196|      1|    U32TO8(msglen + 0, hi);
  ------------------
  |  |   50|      1|    (p)[0] = (uint8_t)((v) >> 24); (p)[1] = (uint8_t)((v) >> 16); \
  |  |   51|      1|    (p)[2] = (uint8_t)((v) >>  8); (p)[3] = (uint8_t)((v)      );
  ------------------
  197|      1|    U32TO8(msglen + 4, lo);
  ------------------
  |  |   50|      1|    (p)[0] = (uint8_t)((v) >> 24); (p)[1] = (uint8_t)((v) >> 16); \
  |  |   51|      1|    (p)[2] = (uint8_t)((v) >>  8); (p)[3] = (uint8_t)((v)      );
  ------------------
  198|       |
  199|      1|    if (S->buflen == 440) { /* one padding byte */
  ------------------
  |  Branch (199:9): [True: 0, False: 1]
  ------------------
  200|      0|        S->t[0] -= 8;
  201|      0|        blake256_update(S, &pa, 8);
  202|      1|    } else {
  203|      1|        if (S->buflen < 440) { /* enough space to fill the block  */
  ------------------
  |  Branch (203:13): [True: 1, False: 0]
  ------------------
  204|      1|            if (S->buflen == 0) S->nullt = 1;
  ------------------
  |  Branch (204:17): [True: 0, False: 1]
  ------------------
  205|      1|            S->t[0] -= 440 - S->buflen;
  206|      1|            blake256_update(S, padding, 440 - S->buflen);
  207|      1|        } else { /* need 2 compressions */
  208|      0|            S->t[0] -= 512 - S->buflen;
  209|      0|            blake256_update(S, padding, 512 - S->buflen);
  210|      0|            S->t[0] -= 440;
  211|      0|            blake256_update(S, padding + 1, 440);
  212|      0|            S->nullt = 1;
  213|      0|        }
  214|      1|        blake256_update(S, &pb, 8);
  215|      1|        S->t[0] -= 8;
  216|      1|    }
  217|      1|    S->t[0] -= 64;
  218|      1|    blake256_update(S, msglen, 64);
  219|       |
  220|      1|    U32TO8(digest +  0, S->h[0]);
  ------------------
  |  |   50|      1|    (p)[0] = (uint8_t)((v) >> 24); (p)[1] = (uint8_t)((v) >> 16); \
  |  |   51|      1|    (p)[2] = (uint8_t)((v) >>  8); (p)[3] = (uint8_t)((v)      );
  ------------------
  221|      1|    U32TO8(digest +  4, S->h[1]);
  ------------------
  |  |   50|      1|    (p)[0] = (uint8_t)((v) >> 24); (p)[1] = (uint8_t)((v) >> 16); \
  |  |   51|      1|    (p)[2] = (uint8_t)((v) >>  8); (p)[3] = (uint8_t)((v)      );
  ------------------
  222|      1|    U32TO8(digest +  8, S->h[2]);
  ------------------
  |  |   50|      1|    (p)[0] = (uint8_t)((v) >> 24); (p)[1] = (uint8_t)((v) >> 16); \
  |  |   51|      1|    (p)[2] = (uint8_t)((v) >>  8); (p)[3] = (uint8_t)((v)      );
  ------------------
  223|      1|    U32TO8(digest + 12, S->h[3]);
  ------------------
  |  |   50|      1|    (p)[0] = (uint8_t)((v) >> 24); (p)[1] = (uint8_t)((v) >> 16); \
  |  |   51|      1|    (p)[2] = (uint8_t)((v) >>  8); (p)[3] = (uint8_t)((v)      );
  ------------------
  224|      1|    U32TO8(digest + 16, S->h[4]);
  ------------------
  |  |   50|      1|    (p)[0] = (uint8_t)((v) >> 24); (p)[1] = (uint8_t)((v) >> 16); \
  |  |   51|      1|    (p)[2] = (uint8_t)((v) >>  8); (p)[3] = (uint8_t)((v)      );
  ------------------
  225|      1|    U32TO8(digest + 20, S->h[5]);
  ------------------
  |  |   50|      1|    (p)[0] = (uint8_t)((v) >> 24); (p)[1] = (uint8_t)((v) >> 16); \
  |  |   51|      1|    (p)[2] = (uint8_t)((v) >>  8); (p)[3] = (uint8_t)((v)      );
  ------------------
  226|      1|    U32TO8(digest + 24, S->h[6]);
  ------------------
  |  |   50|      1|    (p)[0] = (uint8_t)((v) >> 24); (p)[1] = (uint8_t)((v) >> 16); \
  |  |   51|      1|    (p)[2] = (uint8_t)((v) >>  8); (p)[3] = (uint8_t)((v)      );
  ------------------
  227|      1|    U32TO8(digest + 28, S->h[7]);
  ------------------
  |  |   50|      1|    (p)[0] = (uint8_t)((v) >> 24); (p)[1] = (uint8_t)((v) >> 16); \
  |  |   51|      1|    (p)[2] = (uint8_t)((v) >>  8); (p)[3] = (uint8_t)((v)      );
  ------------------
  228|      1|}
blake256_final:
  230|      1|void blake256_final(state *S, uint8_t *digest) {
  231|      1|    blake256_final_h(S, digest, 0x81, 0x01);
  232|      1|}
blake256_hash:
  239|      1|void blake256_hash(uint8_t *out, const uint8_t *in, uint64_t inlen) {
  240|      1|    state S;
  241|      1|    blake256_init(&S);
  242|      1|    blake256_update(&S, in, inlen * 8);
  243|      1|    blake256_final(&S, out);
  244|      1|}

chacha20:
  180|  5.59k|{
  181|  5.59k|  chacha(20, data, length, key, iv, cipher);
  182|  5.59k|}
chacha.c:chacha:
   45|  5.59k|static void chacha(unsigned rounds, const void* data, size_t length, const uint8_t* key, const uint8_t* iv, char* cipher) {
   46|  5.59k|  uint32_t x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15;
   47|  5.59k|  uint32_t j0, j1, j2, j3, j4, j5, j6, j7, j8, j9, j10, j11, j12, j13, j14, j15;
   48|  5.59k|  char* ctarget = 0;
   49|  5.59k|  char tmp[64];
   50|  5.59k|  int i;
   51|       |
   52|  5.59k|  if (!length) return;
  ------------------
  |  Branch (52:7): [True: 0, False: 5.59k]
  ------------------
   53|       |
   54|  5.59k|  j0  = U8TO32_LITTLE(sigma + 0);
  ------------------
  |  |   27|  5.59k|#define U8TO32_LITTLE(p) SWAP32LE(((uint32_t*)(p))[0])
  |  |  ------------------
  |  |  |  |  277|  5.59k|#define SWAP32LE IDENT32
  |  |  |  |  ------------------
  |  |  |  |  |  |  153|  5.59k|#define IDENT32(x) ((uint32_t) (x))
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   55|  5.59k|  j1  = U8TO32_LITTLE(sigma + 4);
  ------------------
  |  |   27|  5.59k|#define U8TO32_LITTLE(p) SWAP32LE(((uint32_t*)(p))[0])
  |  |  ------------------
  |  |  |  |  277|  5.59k|#define SWAP32LE IDENT32
  |  |  |  |  ------------------
  |  |  |  |  |  |  153|  5.59k|#define IDENT32(x) ((uint32_t) (x))
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   56|  5.59k|  j2  = U8TO32_LITTLE(sigma + 8);
  ------------------
  |  |   27|  5.59k|#define U8TO32_LITTLE(p) SWAP32LE(((uint32_t*)(p))[0])
  |  |  ------------------
  |  |  |  |  277|  5.59k|#define SWAP32LE IDENT32
  |  |  |  |  ------------------
  |  |  |  |  |  |  153|  5.59k|#define IDENT32(x) ((uint32_t) (x))
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   57|  5.59k|  j3  = U8TO32_LITTLE(sigma + 12);
  ------------------
  |  |   27|  5.59k|#define U8TO32_LITTLE(p) SWAP32LE(((uint32_t*)(p))[0])
  |  |  ------------------
  |  |  |  |  277|  5.59k|#define SWAP32LE IDENT32
  |  |  |  |  ------------------
  |  |  |  |  |  |  153|  5.59k|#define IDENT32(x) ((uint32_t) (x))
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   58|  5.59k|  j4  = U8TO32_LITTLE(key + 0);
  ------------------
  |  |   27|  5.59k|#define U8TO32_LITTLE(p) SWAP32LE(((uint32_t*)(p))[0])
  |  |  ------------------
  |  |  |  |  277|  5.59k|#define SWAP32LE IDENT32
  |  |  |  |  ------------------
  |  |  |  |  |  |  153|  5.59k|#define IDENT32(x) ((uint32_t) (x))
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   59|  5.59k|  j5  = U8TO32_LITTLE(key + 4);
  ------------------
  |  |   27|  5.59k|#define U8TO32_LITTLE(p) SWAP32LE(((uint32_t*)(p))[0])
  |  |  ------------------
  |  |  |  |  277|  5.59k|#define SWAP32LE IDENT32
  |  |  |  |  ------------------
  |  |  |  |  |  |  153|  5.59k|#define IDENT32(x) ((uint32_t) (x))
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   60|  5.59k|  j6  = U8TO32_LITTLE(key + 8);
  ------------------
  |  |   27|  5.59k|#define U8TO32_LITTLE(p) SWAP32LE(((uint32_t*)(p))[0])
  |  |  ------------------
  |  |  |  |  277|  5.59k|#define SWAP32LE IDENT32
  |  |  |  |  ------------------
  |  |  |  |  |  |  153|  5.59k|#define IDENT32(x) ((uint32_t) (x))
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   61|  5.59k|  j7  = U8TO32_LITTLE(key + 12);
  ------------------
  |  |   27|  5.59k|#define U8TO32_LITTLE(p) SWAP32LE(((uint32_t*)(p))[0])
  |  |  ------------------
  |  |  |  |  277|  5.59k|#define SWAP32LE IDENT32
  |  |  |  |  ------------------
  |  |  |  |  |  |  153|  5.59k|#define IDENT32(x) ((uint32_t) (x))
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   62|  5.59k|  j8  = U8TO32_LITTLE(key + 16);
  ------------------
  |  |   27|  5.59k|#define U8TO32_LITTLE(p) SWAP32LE(((uint32_t*)(p))[0])
  |  |  ------------------
  |  |  |  |  277|  5.59k|#define SWAP32LE IDENT32
  |  |  |  |  ------------------
  |  |  |  |  |  |  153|  5.59k|#define IDENT32(x) ((uint32_t) (x))
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   63|  5.59k|  j9  = U8TO32_LITTLE(key + 20);
  ------------------
  |  |   27|  5.59k|#define U8TO32_LITTLE(p) SWAP32LE(((uint32_t*)(p))[0])
  |  |  ------------------
  |  |  |  |  277|  5.59k|#define SWAP32LE IDENT32
  |  |  |  |  ------------------
  |  |  |  |  |  |  153|  5.59k|#define IDENT32(x) ((uint32_t) (x))
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   64|  5.59k|  j10 = U8TO32_LITTLE(key + 24);
  ------------------
  |  |   27|  5.59k|#define U8TO32_LITTLE(p) SWAP32LE(((uint32_t*)(p))[0])
  |  |  ------------------
  |  |  |  |  277|  5.59k|#define SWAP32LE IDENT32
  |  |  |  |  ------------------
  |  |  |  |  |  |  153|  5.59k|#define IDENT32(x) ((uint32_t) (x))
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   65|  5.59k|  j11 = U8TO32_LITTLE(key + 28);
  ------------------
  |  |   27|  5.59k|#define U8TO32_LITTLE(p) SWAP32LE(((uint32_t*)(p))[0])
  |  |  ------------------
  |  |  |  |  277|  5.59k|#define SWAP32LE IDENT32
  |  |  |  |  ------------------
  |  |  |  |  |  |  153|  5.59k|#define IDENT32(x) ((uint32_t) (x))
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   66|  5.59k|  j12 = 0;
   67|  5.59k|  j13 = 0;
   68|  5.59k|  j14 = U8TO32_LITTLE(iv + 0);
  ------------------
  |  |   27|  5.59k|#define U8TO32_LITTLE(p) SWAP32LE(((uint32_t*)(p))[0])
  |  |  ------------------
  |  |  |  |  277|  5.59k|#define SWAP32LE IDENT32
  |  |  |  |  ------------------
  |  |  |  |  |  |  153|  5.59k|#define IDENT32(x) ((uint32_t) (x))
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   69|  5.59k|  j15 = U8TO32_LITTLE(iv + 4);
  ------------------
  |  |   27|  5.59k|#define U8TO32_LITTLE(p) SWAP32LE(((uint32_t*)(p))[0])
  |  |  ------------------
  |  |  |  |  277|  5.59k|#define SWAP32LE IDENT32
  |  |  |  |  ------------------
  |  |  |  |  |  |  153|  5.59k|#define IDENT32(x) ((uint32_t) (x))
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   70|       |
   71|  21.9k|  for (;;) {
   72|  21.9k|    if (length < 64) {
  ------------------
  |  Branch (72:9): [True: 5.59k, False: 16.3k]
  ------------------
   73|  5.59k|      memcpy(tmp, data, length);
   74|  5.59k|      data = tmp;
   75|  5.59k|      ctarget = cipher;
   76|  5.59k|      cipher = tmp;
   77|  5.59k|    }
   78|  21.9k|    x0  = j0;
   79|  21.9k|    x1  = j1;
   80|  21.9k|    x2  = j2;
   81|  21.9k|    x3  = j3;
   82|  21.9k|    x4  = j4;
   83|  21.9k|    x5  = j5;
   84|  21.9k|    x6  = j6;
   85|  21.9k|    x7  = j7;
   86|  21.9k|    x8  = j8;
   87|  21.9k|    x9  = j9;
   88|  21.9k|    x10 = j10;
   89|  21.9k|    x11 = j11;
   90|  21.9k|    x12 = j12;
   91|  21.9k|    x13 = j13;
   92|  21.9k|    x14 = j14;
   93|  21.9k|    x15 = j15;
   94|   241k|    for (i = rounds;i > 0;i -= 2) {
  ------------------
  |  Branch (94:21): [True: 219k, False: 21.9k]
  ------------------
   95|   219k|      QUARTERROUND( x0, x4, x8,x12)
  ------------------
  |  |   36|   219k|  a = PLUS(a,b); d = ROTATE(XOR(d,a),16); \
  |  |  ------------------
  |  |  |  |   32|   219k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  |  |  ------------------
  |  |  |  |  |  |   21|   219k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 a = PLUS(a,b); d = ROTATE(XOR(d,a),16); \
  |  |  ------------------
  |  |  |  |   30|   219k|#define ROTATE(v,c) (rol32(v,c))
  |  |  ------------------
  |  |   37|   219k|  c = PLUS(c,d); b = ROTATE(XOR(b,c),12); \
  |  |  ------------------
  |  |  |  |   32|   219k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  |  |  ------------------
  |  |  |  |  |  |   21|   219k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 c = PLUS(c,d); b = ROTATE(XOR(b,c),12); \
  |  |  ------------------
  |  |  |  |   30|   219k|#define ROTATE(v,c) (rol32(v,c))
  |  |  ------------------
  |  |   38|   219k|  a = PLUS(a,b); d = ROTATE(XOR(d,a), 8); \
  |  |  ------------------
  |  |  |  |   32|   219k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  |  |  ------------------
  |  |  |  |  |  |   21|   219k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 a = PLUS(a,b); d = ROTATE(XOR(d,a), 8); \
  |  |  ------------------
  |  |  |  |   30|   219k|#define ROTATE(v,c) (rol32(v,c))
  |  |  ------------------
  |  |   39|   219k|  c = PLUS(c,d); b = ROTATE(XOR(b,c), 7);
  |  |  ------------------
  |  |  |  |   32|   219k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  |  |  ------------------
  |  |  |  |  |  |   21|   219k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 c = PLUS(c,d); b = ROTATE(XOR(b,c), 7);
  |  |  ------------------
  |  |  |  |   30|   219k|#define ROTATE(v,c) (rol32(v,c))
  |  |  ------------------
  ------------------
   96|   219k|      QUARTERROUND( x1, x5, x9,x13)
  ------------------
  |  |   36|   219k|  a = PLUS(a,b); d = ROTATE(XOR(d,a),16); \
  |  |  ------------------
  |  |  |  |   32|   219k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  |  |  ------------------
  |  |  |  |  |  |   21|   219k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 a = PLUS(a,b); d = ROTATE(XOR(d,a),16); \
  |  |  ------------------
  |  |  |  |   30|   219k|#define ROTATE(v,c) (rol32(v,c))
  |  |  ------------------
  |  |   37|   219k|  c = PLUS(c,d); b = ROTATE(XOR(b,c),12); \
  |  |  ------------------
  |  |  |  |   32|   219k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  |  |  ------------------
  |  |  |  |  |  |   21|   219k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 c = PLUS(c,d); b = ROTATE(XOR(b,c),12); \
  |  |  ------------------
  |  |  |  |   30|   219k|#define ROTATE(v,c) (rol32(v,c))
  |  |  ------------------
  |  |   38|   219k|  a = PLUS(a,b); d = ROTATE(XOR(d,a), 8); \
  |  |  ------------------
  |  |  |  |   32|   219k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  |  |  ------------------
  |  |  |  |  |  |   21|   219k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 a = PLUS(a,b); d = ROTATE(XOR(d,a), 8); \
  |  |  ------------------
  |  |  |  |   30|   219k|#define ROTATE(v,c) (rol32(v,c))
  |  |  ------------------
  |  |   39|   219k|  c = PLUS(c,d); b = ROTATE(XOR(b,c), 7);
  |  |  ------------------
  |  |  |  |   32|   219k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  |  |  ------------------
  |  |  |  |  |  |   21|   219k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 c = PLUS(c,d); b = ROTATE(XOR(b,c), 7);
  |  |  ------------------
  |  |  |  |   30|   219k|#define ROTATE(v,c) (rol32(v,c))
  |  |  ------------------
  ------------------
   97|   219k|      QUARTERROUND( x2, x6,x10,x14)
  ------------------
  |  |   36|   219k|  a = PLUS(a,b); d = ROTATE(XOR(d,a),16); \
  |  |  ------------------
  |  |  |  |   32|   219k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  |  |  ------------------
  |  |  |  |  |  |   21|   219k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 a = PLUS(a,b); d = ROTATE(XOR(d,a),16); \
  |  |  ------------------
  |  |  |  |   30|   219k|#define ROTATE(v,c) (rol32(v,c))
  |  |  ------------------
  |  |   37|   219k|  c = PLUS(c,d); b = ROTATE(XOR(b,c),12); \
  |  |  ------------------
  |  |  |  |   32|   219k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  |  |  ------------------
  |  |  |  |  |  |   21|   219k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 c = PLUS(c,d); b = ROTATE(XOR(b,c),12); \
  |  |  ------------------
  |  |  |  |   30|   219k|#define ROTATE(v,c) (rol32(v,c))
  |  |  ------------------
  |  |   38|   219k|  a = PLUS(a,b); d = ROTATE(XOR(d,a), 8); \
  |  |  ------------------
  |  |  |  |   32|   219k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  |  |  ------------------
  |  |  |  |  |  |   21|   219k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 a = PLUS(a,b); d = ROTATE(XOR(d,a), 8); \
  |  |  ------------------
  |  |  |  |   30|   219k|#define ROTATE(v,c) (rol32(v,c))
  |  |  ------------------
  |  |   39|   219k|  c = PLUS(c,d); b = ROTATE(XOR(b,c), 7);
  |  |  ------------------
  |  |  |  |   32|   219k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  |  |  ------------------
  |  |  |  |  |  |   21|   219k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 c = PLUS(c,d); b = ROTATE(XOR(b,c), 7);
  |  |  ------------------
  |  |  |  |   30|   219k|#define ROTATE(v,c) (rol32(v,c))
  |  |  ------------------
  ------------------
   98|   219k|      QUARTERROUND( x3, x7,x11,x15)
  ------------------
  |  |   36|   219k|  a = PLUS(a,b); d = ROTATE(XOR(d,a),16); \
  |  |  ------------------
  |  |  |  |   32|   219k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  |  |  ------------------
  |  |  |  |  |  |   21|   219k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 a = PLUS(a,b); d = ROTATE(XOR(d,a),16); \
  |  |  ------------------
  |  |  |  |   30|   219k|#define ROTATE(v,c) (rol32(v,c))
  |  |  ------------------
  |  |   37|   219k|  c = PLUS(c,d); b = ROTATE(XOR(b,c),12); \
  |  |  ------------------
  |  |  |  |   32|   219k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  |  |  ------------------
  |  |  |  |  |  |   21|   219k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 c = PLUS(c,d); b = ROTATE(XOR(b,c),12); \
  |  |  ------------------
  |  |  |  |   30|   219k|#define ROTATE(v,c) (rol32(v,c))
  |  |  ------------------
  |  |   38|   219k|  a = PLUS(a,b); d = ROTATE(XOR(d,a), 8); \
  |  |  ------------------
  |  |  |  |   32|   219k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  |  |  ------------------
  |  |  |  |  |  |   21|   219k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 a = PLUS(a,b); d = ROTATE(XOR(d,a), 8); \
  |  |  ------------------
  |  |  |  |   30|   219k|#define ROTATE(v,c) (rol32(v,c))
  |  |  ------------------
  |  |   39|   219k|  c = PLUS(c,d); b = ROTATE(XOR(b,c), 7);
  |  |  ------------------
  |  |  |  |   32|   219k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  |  |  ------------------
  |  |  |  |  |  |   21|   219k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 c = PLUS(c,d); b = ROTATE(XOR(b,c), 7);
  |  |  ------------------
  |  |  |  |   30|   219k|#define ROTATE(v,c) (rol32(v,c))
  |  |  ------------------
  ------------------
   99|   219k|      QUARTERROUND( x0, x5,x10,x15)
  ------------------
  |  |   36|   219k|  a = PLUS(a,b); d = ROTATE(XOR(d,a),16); \
  |  |  ------------------
  |  |  |  |   32|   219k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  |  |  ------------------
  |  |  |  |  |  |   21|   219k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 a = PLUS(a,b); d = ROTATE(XOR(d,a),16); \
  |  |  ------------------
  |  |  |  |   30|   219k|#define ROTATE(v,c) (rol32(v,c))
  |  |  ------------------
  |  |   37|   219k|  c = PLUS(c,d); b = ROTATE(XOR(b,c),12); \
  |  |  ------------------
  |  |  |  |   32|   219k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  |  |  ------------------
  |  |  |  |  |  |   21|   219k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 c = PLUS(c,d); b = ROTATE(XOR(b,c),12); \
  |  |  ------------------
  |  |  |  |   30|   219k|#define ROTATE(v,c) (rol32(v,c))
  |  |  ------------------
  |  |   38|   219k|  a = PLUS(a,b); d = ROTATE(XOR(d,a), 8); \
  |  |  ------------------
  |  |  |  |   32|   219k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  |  |  ------------------
  |  |  |  |  |  |   21|   219k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 a = PLUS(a,b); d = ROTATE(XOR(d,a), 8); \
  |  |  ------------------
  |  |  |  |   30|   219k|#define ROTATE(v,c) (rol32(v,c))
  |  |  ------------------
  |  |   39|   219k|  c = PLUS(c,d); b = ROTATE(XOR(b,c), 7);
  |  |  ------------------
  |  |  |  |   32|   219k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  |  |  ------------------
  |  |  |  |  |  |   21|   219k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 c = PLUS(c,d); b = ROTATE(XOR(b,c), 7);
  |  |  ------------------
  |  |  |  |   30|   219k|#define ROTATE(v,c) (rol32(v,c))
  |  |  ------------------
  ------------------
  100|   219k|      QUARTERROUND( x1, x6,x11,x12)
  ------------------
  |  |   36|   219k|  a = PLUS(a,b); d = ROTATE(XOR(d,a),16); \
  |  |  ------------------
  |  |  |  |   32|   219k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  |  |  ------------------
  |  |  |  |  |  |   21|   219k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 a = PLUS(a,b); d = ROTATE(XOR(d,a),16); \
  |  |  ------------------
  |  |  |  |   30|   219k|#define ROTATE(v,c) (rol32(v,c))
  |  |  ------------------
  |  |   37|   219k|  c = PLUS(c,d); b = ROTATE(XOR(b,c),12); \
  |  |  ------------------
  |  |  |  |   32|   219k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  |  |  ------------------
  |  |  |  |  |  |   21|   219k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 c = PLUS(c,d); b = ROTATE(XOR(b,c),12); \
  |  |  ------------------
  |  |  |  |   30|   219k|#define ROTATE(v,c) (rol32(v,c))
  |  |  ------------------
  |  |   38|   219k|  a = PLUS(a,b); d = ROTATE(XOR(d,a), 8); \
  |  |  ------------------
  |  |  |  |   32|   219k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  |  |  ------------------
  |  |  |  |  |  |   21|   219k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 a = PLUS(a,b); d = ROTATE(XOR(d,a), 8); \
  |  |  ------------------
  |  |  |  |   30|   219k|#define ROTATE(v,c) (rol32(v,c))
  |  |  ------------------
  |  |   39|   219k|  c = PLUS(c,d); b = ROTATE(XOR(b,c), 7);
  |  |  ------------------
  |  |  |  |   32|   219k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  |  |  ------------------
  |  |  |  |  |  |   21|   219k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 c = PLUS(c,d); b = ROTATE(XOR(b,c), 7);
  |  |  ------------------
  |  |  |  |   30|   219k|#define ROTATE(v,c) (rol32(v,c))
  |  |  ------------------
  ------------------
  101|   219k|      QUARTERROUND( x2, x7, x8,x13)
  ------------------
  |  |   36|   219k|  a = PLUS(a,b); d = ROTATE(XOR(d,a),16); \
  |  |  ------------------
  |  |  |  |   32|   219k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  |  |  ------------------
  |  |  |  |  |  |   21|   219k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 a = PLUS(a,b); d = ROTATE(XOR(d,a),16); \
  |  |  ------------------
  |  |  |  |   30|   219k|#define ROTATE(v,c) (rol32(v,c))
  |  |  ------------------
  |  |   37|   219k|  c = PLUS(c,d); b = ROTATE(XOR(b,c),12); \
  |  |  ------------------
  |  |  |  |   32|   219k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  |  |  ------------------
  |  |  |  |  |  |   21|   219k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 c = PLUS(c,d); b = ROTATE(XOR(b,c),12); \
  |  |  ------------------
  |  |  |  |   30|   219k|#define ROTATE(v,c) (rol32(v,c))
  |  |  ------------------
  |  |   38|   219k|  a = PLUS(a,b); d = ROTATE(XOR(d,a), 8); \
  |  |  ------------------
  |  |  |  |   32|   219k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  |  |  ------------------
  |  |  |  |  |  |   21|   219k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 a = PLUS(a,b); d = ROTATE(XOR(d,a), 8); \
  |  |  ------------------
  |  |  |  |   30|   219k|#define ROTATE(v,c) (rol32(v,c))
  |  |  ------------------
  |  |   39|   219k|  c = PLUS(c,d); b = ROTATE(XOR(b,c), 7);
  |  |  ------------------
  |  |  |  |   32|   219k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  |  |  ------------------
  |  |  |  |  |  |   21|   219k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 c = PLUS(c,d); b = ROTATE(XOR(b,c), 7);
  |  |  ------------------
  |  |  |  |   30|   219k|#define ROTATE(v,c) (rol32(v,c))
  |  |  ------------------
  ------------------
  102|   219k|      QUARTERROUND( x3, x4, x9,x14)
  ------------------
  |  |   36|   219k|  a = PLUS(a,b); d = ROTATE(XOR(d,a),16); \
  |  |  ------------------
  |  |  |  |   32|   219k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  |  |  ------------------
  |  |  |  |  |  |   21|   219k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 a = PLUS(a,b); d = ROTATE(XOR(d,a),16); \
  |  |  ------------------
  |  |  |  |   30|   219k|#define ROTATE(v,c) (rol32(v,c))
  |  |  ------------------
  |  |   37|   219k|  c = PLUS(c,d); b = ROTATE(XOR(b,c),12); \
  |  |  ------------------
  |  |  |  |   32|   219k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  |  |  ------------------
  |  |  |  |  |  |   21|   219k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 c = PLUS(c,d); b = ROTATE(XOR(b,c),12); \
  |  |  ------------------
  |  |  |  |   30|   219k|#define ROTATE(v,c) (rol32(v,c))
  |  |  ------------------
  |  |   38|   219k|  a = PLUS(a,b); d = ROTATE(XOR(d,a), 8); \
  |  |  ------------------
  |  |  |  |   32|   219k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  |  |  ------------------
  |  |  |  |  |  |   21|   219k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 a = PLUS(a,b); d = ROTATE(XOR(d,a), 8); \
  |  |  ------------------
  |  |  |  |   30|   219k|#define ROTATE(v,c) (rol32(v,c))
  |  |  ------------------
  |  |   39|   219k|  c = PLUS(c,d); b = ROTATE(XOR(b,c), 7);
  |  |  ------------------
  |  |  |  |   32|   219k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  |  |  ------------------
  |  |  |  |  |  |   21|   219k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                 c = PLUS(c,d); b = ROTATE(XOR(b,c), 7);
  |  |  ------------------
  |  |  |  |   30|   219k|#define ROTATE(v,c) (rol32(v,c))
  |  |  ------------------
  ------------------
  103|   219k|    }
  104|  21.9k|    x0  = PLUS( x0, j0);
  ------------------
  |  |   32|  21.9k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  ------------------
  |  |  |  |   21|  21.9k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  ------------------
  ------------------
  105|  21.9k|    x1  = PLUS( x1, j1);
  ------------------
  |  |   32|  21.9k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  ------------------
  |  |  |  |   21|  21.9k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  ------------------
  ------------------
  106|  21.9k|    x2  = PLUS( x2, j2);
  ------------------
  |  |   32|  21.9k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  ------------------
  |  |  |  |   21|  21.9k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  ------------------
  ------------------
  107|  21.9k|    x3  = PLUS( x3, j3);
  ------------------
  |  |   32|  21.9k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  ------------------
  |  |  |  |   21|  21.9k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  ------------------
  ------------------
  108|  21.9k|    x4  = PLUS( x4, j4);
  ------------------
  |  |   32|  21.9k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  ------------------
  |  |  |  |   21|  21.9k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  ------------------
  ------------------
  109|  21.9k|    x5  = PLUS( x5, j5);
  ------------------
  |  |   32|  21.9k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  ------------------
  |  |  |  |   21|  21.9k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  ------------------
  ------------------
  110|  21.9k|    x6  = PLUS( x6, j6);
  ------------------
  |  |   32|  21.9k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  ------------------
  |  |  |  |   21|  21.9k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  ------------------
  ------------------
  111|  21.9k|    x7  = PLUS( x7, j7);
  ------------------
  |  |   32|  21.9k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  ------------------
  |  |  |  |   21|  21.9k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  ------------------
  ------------------
  112|  21.9k|    x8  = PLUS( x8, j8);
  ------------------
  |  |   32|  21.9k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  ------------------
  |  |  |  |   21|  21.9k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  ------------------
  ------------------
  113|  21.9k|    x9  = PLUS( x9, j9);
  ------------------
  |  |   32|  21.9k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  ------------------
  |  |  |  |   21|  21.9k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  ------------------
  ------------------
  114|  21.9k|    x10 = PLUS(x10,j10);
  ------------------
  |  |   32|  21.9k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  ------------------
  |  |  |  |   21|  21.9k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  ------------------
  ------------------
  115|  21.9k|    x11 = PLUS(x11,j11);
  ------------------
  |  |   32|  21.9k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  ------------------
  |  |  |  |   21|  21.9k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  ------------------
  ------------------
  116|  21.9k|    x12 = PLUS(x12,j12);
  ------------------
  |  |   32|  21.9k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  ------------------
  |  |  |  |   21|  21.9k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  ------------------
  ------------------
  117|  21.9k|    x13 = PLUS(x13,j13);
  ------------------
  |  |   32|  21.9k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  ------------------
  |  |  |  |   21|  21.9k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  ------------------
  ------------------
  118|  21.9k|    x14 = PLUS(x14,j14);
  ------------------
  |  |   32|  21.9k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  ------------------
  |  |  |  |   21|  21.9k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  ------------------
  ------------------
  119|  21.9k|    x15 = PLUS(x15,j15);
  ------------------
  |  |   32|  21.9k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  ------------------
  |  |  |  |   21|  21.9k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  ------------------
  ------------------
  120|       |
  121|  21.9k|    x0  = XOR( x0,U8TO32_LITTLE((uint8_t*)data +  0));
  ------------------
  |  |   31|  21.9k|#define XOR(v,w) ((v) ^ (w))
  ------------------
  122|  21.9k|    x1  = XOR( x1,U8TO32_LITTLE((uint8_t*)data +  4));
  ------------------
  |  |   31|  21.9k|#define XOR(v,w) ((v) ^ (w))
  ------------------
  123|  21.9k|    x2  = XOR( x2,U8TO32_LITTLE((uint8_t*)data +  8));
  ------------------
  |  |   31|  21.9k|#define XOR(v,w) ((v) ^ (w))
  ------------------
  124|  21.9k|    x3  = XOR( x3,U8TO32_LITTLE((uint8_t*)data + 12));
  ------------------
  |  |   31|  21.9k|#define XOR(v,w) ((v) ^ (w))
  ------------------
  125|  21.9k|    x4  = XOR( x4,U8TO32_LITTLE((uint8_t*)data + 16));
  ------------------
  |  |   31|  21.9k|#define XOR(v,w) ((v) ^ (w))
  ------------------
  126|  21.9k|    x5  = XOR( x5,U8TO32_LITTLE((uint8_t*)data + 20));
  ------------------
  |  |   31|  21.9k|#define XOR(v,w) ((v) ^ (w))
  ------------------
  127|  21.9k|    x6  = XOR( x6,U8TO32_LITTLE((uint8_t*)data + 24));
  ------------------
  |  |   31|  21.9k|#define XOR(v,w) ((v) ^ (w))
  ------------------
  128|  21.9k|    x7  = XOR( x7,U8TO32_LITTLE((uint8_t*)data + 28));
  ------------------
  |  |   31|  21.9k|#define XOR(v,w) ((v) ^ (w))
  ------------------
  129|  21.9k|    x8  = XOR( x8,U8TO32_LITTLE((uint8_t*)data + 32));
  ------------------
  |  |   31|  21.9k|#define XOR(v,w) ((v) ^ (w))
  ------------------
  130|  21.9k|    x9  = XOR( x9,U8TO32_LITTLE((uint8_t*)data + 36));
  ------------------
  |  |   31|  21.9k|#define XOR(v,w) ((v) ^ (w))
  ------------------
  131|  21.9k|    x10 = XOR(x10,U8TO32_LITTLE((uint8_t*)data + 40));
  ------------------
  |  |   31|  21.9k|#define XOR(v,w) ((v) ^ (w))
  ------------------
  132|  21.9k|    x11 = XOR(x11,U8TO32_LITTLE((uint8_t*)data + 44));
  ------------------
  |  |   31|  21.9k|#define XOR(v,w) ((v) ^ (w))
  ------------------
  133|  21.9k|    x12 = XOR(x12,U8TO32_LITTLE((uint8_t*)data + 48));
  ------------------
  |  |   31|  21.9k|#define XOR(v,w) ((v) ^ (w))
  ------------------
  134|  21.9k|    x13 = XOR(x13,U8TO32_LITTLE((uint8_t*)data + 52));
  ------------------
  |  |   31|  21.9k|#define XOR(v,w) ((v) ^ (w))
  ------------------
  135|  21.9k|    x14 = XOR(x14,U8TO32_LITTLE((uint8_t*)data + 56));
  ------------------
  |  |   31|  21.9k|#define XOR(v,w) ((v) ^ (w))
  ------------------
  136|  21.9k|    x15 = XOR(x15,U8TO32_LITTLE((uint8_t*)data + 60));
  ------------------
  |  |   31|  21.9k|#define XOR(v,w) ((v) ^ (w))
  ------------------
  137|       |
  138|  21.9k|    j12 = PLUSONE(j12);
  ------------------
  |  |   33|  21.9k|#define PLUSONE(v) (PLUS((v),1))
  |  |  ------------------
  |  |  |  |   32|  21.9k|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  |  |  ------------------
  |  |  |  |  |  |   21|  21.9k|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  139|  21.9k|    if (!j12)
  ------------------
  |  Branch (139:9): [True: 0, False: 21.9k]
  ------------------
  140|      0|    {
  141|      0|      j13 = PLUSONE(j13);
  ------------------
  |  |   33|      0|#define PLUSONE(v) (PLUS((v),1))
  |  |  ------------------
  |  |  |  |   32|      0|#define PLUS(v,w) (U32V((v) + (w)))
  |  |  |  |  ------------------
  |  |  |  |  |  |   21|      0|#define U32V(v) ((uint32_t)(v) & UINT32_C(0xFFFFFFFF))
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  142|       |      /* stopping at 2^70 bytes per iv is user's responsibility */
  143|      0|    }
  144|       |
  145|  21.9k|    U32TO8_LITTLE(cipher +  0,x0);
  ------------------
  |  |   28|  21.9k|#define U32TO8_LITTLE(p, v) (((uint32_t*)(p))[0] = SWAP32LE(v))
  |  |  ------------------
  |  |  |  |  277|  21.9k|#define SWAP32LE IDENT32
  |  |  |  |  ------------------
  |  |  |  |  |  |  153|  21.9k|#define IDENT32(x) ((uint32_t) (x))
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  146|  21.9k|    U32TO8_LITTLE(cipher +  4,x1);
  ------------------
  |  |   28|  21.9k|#define U32TO8_LITTLE(p, v) (((uint32_t*)(p))[0] = SWAP32LE(v))
  |  |  ------------------
  |  |  |  |  277|  21.9k|#define SWAP32LE IDENT32
  |  |  |  |  ------------------
  |  |  |  |  |  |  153|  21.9k|#define IDENT32(x) ((uint32_t) (x))
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  147|  21.9k|    U32TO8_LITTLE(cipher +  8,x2);
  ------------------
  |  |   28|  21.9k|#define U32TO8_LITTLE(p, v) (((uint32_t*)(p))[0] = SWAP32LE(v))
  |  |  ------------------
  |  |  |  |  277|  21.9k|#define SWAP32LE IDENT32
  |  |  |  |  ------------------
  |  |  |  |  |  |  153|  21.9k|#define IDENT32(x) ((uint32_t) (x))
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  148|  21.9k|    U32TO8_LITTLE(cipher + 12,x3);
  ------------------
  |  |   28|  21.9k|#define U32TO8_LITTLE(p, v) (((uint32_t*)(p))[0] = SWAP32LE(v))
  |  |  ------------------
  |  |  |  |  277|  21.9k|#define SWAP32LE IDENT32
  |  |  |  |  ------------------
  |  |  |  |  |  |  153|  21.9k|#define IDENT32(x) ((uint32_t) (x))
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  149|  21.9k|    U32TO8_LITTLE(cipher + 16,x4);
  ------------------
  |  |   28|  21.9k|#define U32TO8_LITTLE(p, v) (((uint32_t*)(p))[0] = SWAP32LE(v))
  |  |  ------------------
  |  |  |  |  277|  21.9k|#define SWAP32LE IDENT32
  |  |  |  |  ------------------
  |  |  |  |  |  |  153|  21.9k|#define IDENT32(x) ((uint32_t) (x))
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  150|  21.9k|    U32TO8_LITTLE(cipher + 20,x5);
  ------------------
  |  |   28|  21.9k|#define U32TO8_LITTLE(p, v) (((uint32_t*)(p))[0] = SWAP32LE(v))
  |  |  ------------------
  |  |  |  |  277|  21.9k|#define SWAP32LE IDENT32
  |  |  |  |  ------------------
  |  |  |  |  |  |  153|  21.9k|#define IDENT32(x) ((uint32_t) (x))
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  151|  21.9k|    U32TO8_LITTLE(cipher + 24,x6);
  ------------------
  |  |   28|  21.9k|#define U32TO8_LITTLE(p, v) (((uint32_t*)(p))[0] = SWAP32LE(v))
  |  |  ------------------
  |  |  |  |  277|  21.9k|#define SWAP32LE IDENT32
  |  |  |  |  ------------------
  |  |  |  |  |  |  153|  21.9k|#define IDENT32(x) ((uint32_t) (x))
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  152|  21.9k|    U32TO8_LITTLE(cipher + 28,x7);
  ------------------
  |  |   28|  21.9k|#define U32TO8_LITTLE(p, v) (((uint32_t*)(p))[0] = SWAP32LE(v))
  |  |  ------------------
  |  |  |  |  277|  21.9k|#define SWAP32LE IDENT32
  |  |  |  |  ------------------
  |  |  |  |  |  |  153|  21.9k|#define IDENT32(x) ((uint32_t) (x))
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  153|  21.9k|    U32TO8_LITTLE(cipher + 32,x8);
  ------------------
  |  |   28|  21.9k|#define U32TO8_LITTLE(p, v) (((uint32_t*)(p))[0] = SWAP32LE(v))
  |  |  ------------------
  |  |  |  |  277|  21.9k|#define SWAP32LE IDENT32
  |  |  |  |  ------------------
  |  |  |  |  |  |  153|  21.9k|#define IDENT32(x) ((uint32_t) (x))
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  154|  21.9k|    U32TO8_LITTLE(cipher + 36,x9);
  ------------------
  |  |   28|  21.9k|#define U32TO8_LITTLE(p, v) (((uint32_t*)(p))[0] = SWAP32LE(v))
  |  |  ------------------
  |  |  |  |  277|  21.9k|#define SWAP32LE IDENT32
  |  |  |  |  ------------------
  |  |  |  |  |  |  153|  21.9k|#define IDENT32(x) ((uint32_t) (x))
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  155|  21.9k|    U32TO8_LITTLE(cipher + 40,x10);
  ------------------
  |  |   28|  21.9k|#define U32TO8_LITTLE(p, v) (((uint32_t*)(p))[0] = SWAP32LE(v))
  |  |  ------------------
  |  |  |  |  277|  21.9k|#define SWAP32LE IDENT32
  |  |  |  |  ------------------
  |  |  |  |  |  |  153|  21.9k|#define IDENT32(x) ((uint32_t) (x))
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  156|  21.9k|    U32TO8_LITTLE(cipher + 44,x11);
  ------------------
  |  |   28|  21.9k|#define U32TO8_LITTLE(p, v) (((uint32_t*)(p))[0] = SWAP32LE(v))
  |  |  ------------------
  |  |  |  |  277|  21.9k|#define SWAP32LE IDENT32
  |  |  |  |  ------------------
  |  |  |  |  |  |  153|  21.9k|#define IDENT32(x) ((uint32_t) (x))
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  157|  21.9k|    U32TO8_LITTLE(cipher + 48,x12);
  ------------------
  |  |   28|  21.9k|#define U32TO8_LITTLE(p, v) (((uint32_t*)(p))[0] = SWAP32LE(v))
  |  |  ------------------
  |  |  |  |  277|  21.9k|#define SWAP32LE IDENT32
  |  |  |  |  ------------------
  |  |  |  |  |  |  153|  21.9k|#define IDENT32(x) ((uint32_t) (x))
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  158|  21.9k|    U32TO8_LITTLE(cipher + 52,x13);
  ------------------
  |  |   28|  21.9k|#define U32TO8_LITTLE(p, v) (((uint32_t*)(p))[0] = SWAP32LE(v))
  |  |  ------------------
  |  |  |  |  277|  21.9k|#define SWAP32LE IDENT32
  |  |  |  |  ------------------
  |  |  |  |  |  |  153|  21.9k|#define IDENT32(x) ((uint32_t) (x))
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  159|  21.9k|    U32TO8_LITTLE(cipher + 56,x14);
  ------------------
  |  |   28|  21.9k|#define U32TO8_LITTLE(p, v) (((uint32_t*)(p))[0] = SWAP32LE(v))
  |  |  ------------------
  |  |  |  |  277|  21.9k|#define SWAP32LE IDENT32
  |  |  |  |  ------------------
  |  |  |  |  |  |  153|  21.9k|#define IDENT32(x) ((uint32_t) (x))
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  160|  21.9k|    U32TO8_LITTLE(cipher + 60,x15);
  ------------------
  |  |   28|  21.9k|#define U32TO8_LITTLE(p, v) (((uint32_t*)(p))[0] = SWAP32LE(v))
  |  |  ------------------
  |  |  |  |  277|  21.9k|#define SWAP32LE IDENT32
  |  |  |  |  ------------------
  |  |  |  |  |  |  153|  21.9k|#define IDENT32(x) ((uint32_t) (x))
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  161|       |
  162|  21.9k|    if (length <= 64) {
  ------------------
  |  Branch (162:9): [True: 5.59k, False: 16.3k]
  ------------------
  163|  5.59k|      if (length < 64) {
  ------------------
  |  Branch (163:11): [True: 5.59k, False: 2]
  ------------------
  164|  5.59k|        memcpy(ctarget, cipher, length);
  165|  5.59k|      }
  166|  5.59k|      return;
  167|  5.59k|    }
  168|  16.3k|    length -= 64;
  169|  16.3k|    cipher += 64;
  170|  16.3k|    data = (uint8_t*)data + 64;
  171|  16.3k|  }
  172|  5.59k|}

_ZN6crypto8chacha20EPKvmRKN4epee7mlockedIN5tools8scrubbedINSt3__15arrayIhLm32EEEEEEERKNS_9chacha_ivEPc:
   69|  5.59k|  inline void chacha20(const void* data, std::size_t length, const chacha_key& key, const chacha_iv& iv, char* cipher) {
   70|  5.59k|    chacha20(data, length, key.data(), reinterpret_cast<const uint8_t*>(&iv), cipher);
   71|  5.59k|  }
_ZN6crypto19generate_chacha_keyEPKvmRN4epee7mlockedIN5tools8scrubbedINSt3__15arrayIhLm32EEEEEEEm:
   73|  5.60k|  inline void generate_chacha_key(const void *data, size_t size, chacha_key& key, uint64_t kdf_rounds) {
   74|  5.60k|    static_assert(sizeof(chacha_key) <= sizeof(hash), "Size of hash must be at least that of chacha_key");
   75|  5.60k|    epee::mlocked<tools::scrubbed_arr<char, HASH_SIZE>> pwd_hash;
   76|  5.60k|    crypto::cn_slow_hash(data, size, pwd_hash.data(), 0/*variant*/, 0/*prehashed*/, 0/*height*/);
   77|  5.60k|    for (uint64_t n = 1; n < kdf_rounds; ++n)
  ------------------
  |  Branch (77:26): [True: 0, False: 5.60k]
  ------------------
   78|      0|      crypto::cn_slow_hash(pwd_hash.data(), pwd_hash.size(), pwd_hash.data(), 0/*variant*/, 0/*prehashed*/, 0/*height*/);
   79|  5.60k|    memcpy(&unwrap(unwrap(key)), pwd_hash.data(), sizeof(key));
   80|  5.60k|  }

load_3:
   50|  1.41M|uint64_t load_3(const unsigned char *in) {
   51|  1.41M|  uint64_t result;
   52|  1.41M|  result = (uint64_t) in[0];
   53|  1.41M|  result |= ((uint64_t) in[1]) << 8;
   54|  1.41M|  result |= ((uint64_t) in[2]) << 16;
   55|  1.41M|  return result;
   56|  1.41M|}
load_4:
   59|  1.45M|{
   60|  1.45M|  uint64_t result;
   61|  1.45M|  result = (uint64_t) in[0];
   62|  1.45M|  result |= ((uint64_t) in[1]) << 8;
   63|  1.45M|  result |= ((uint64_t) in[2]) << 16;
   64|  1.45M|  result |= ((uint64_t) in[3]) << 24;
   65|  1.45M|  return result;
   66|  1.45M|}
fe_0:
   74|  7.23M|void fe_0(fe h) {
   75|  7.23M|  h[0] = 0;
   76|  7.23M|  h[1] = 0;
   77|  7.23M|  h[2] = 0;
   78|  7.23M|  h[3] = 0;
   79|  7.23M|  h[4] = 0;
   80|  7.23M|  h[5] = 0;
   81|  7.23M|  h[6] = 0;
   82|  7.23M|  h[7] = 0;
   83|  7.23M|  h[8] = 0;
   84|  7.23M|  h[9] = 0;
   85|  7.23M|}
fe_add:
  120|  28.9M|void fe_add(fe h, const fe f, const fe g) {
  121|  28.9M|  int32_t f0 = f[0];
  122|  28.9M|  int32_t f1 = f[1];
  123|  28.9M|  int32_t f2 = f[2];
  124|  28.9M|  int32_t f3 = f[3];
  125|  28.9M|  int32_t f4 = f[4];
  126|  28.9M|  int32_t f5 = f[5];
  127|  28.9M|  int32_t f6 = f[6];
  128|  28.9M|  int32_t f7 = f[7];
  129|  28.9M|  int32_t f8 = f[8];
  130|  28.9M|  int32_t f9 = f[9];
  131|  28.9M|  int32_t g0 = g[0];
  132|  28.9M|  int32_t g1 = g[1];
  133|  28.9M|  int32_t g2 = g[2];
  134|  28.9M|  int32_t g3 = g[3];
  135|  28.9M|  int32_t g4 = g[4];
  136|  28.9M|  int32_t g5 = g[5];
  137|  28.9M|  int32_t g6 = g[6];
  138|  28.9M|  int32_t g7 = g[7];
  139|  28.9M|  int32_t g8 = g[8];
  140|  28.9M|  int32_t g9 = g[9];
  141|  28.9M|  int32_t h0 = f0 + g0;
  142|  28.9M|  int32_t h1 = f1 + g1;
  143|  28.9M|  int32_t h2 = f2 + g2;
  144|  28.9M|  int32_t h3 = f3 + g3;
  145|  28.9M|  int32_t h4 = f4 + g4;
  146|  28.9M|  int32_t h5 = f5 + g5;
  147|  28.9M|  int32_t h6 = f6 + g6;
  148|  28.9M|  int32_t h7 = f7 + g7;
  149|  28.9M|  int32_t h8 = f8 + g8;
  150|  28.9M|  int32_t h9 = f9 + g9;
  151|  28.9M|  h[0] = h0;
  152|  28.9M|  h[1] = h1;
  153|  28.9M|  h[2] = h2;
  154|  28.9M|  h[3] = h3;
  155|  28.9M|  h[4] = h4;
  156|  28.9M|  h[5] = h5;
  157|  28.9M|  h[6] = h6;
  158|  28.9M|  h[7] = h7;
  159|  28.9M|  h[8] = h8;
  160|  28.9M|  h[9] = h9;
  161|  28.9M|}
fe_invert:
  258|   109k|void fe_invert(fe out, const fe z) {
  259|   109k|  fe t0;
  260|   109k|  fe t1;
  261|   109k|  fe t2;
  262|   109k|  fe t3;
  263|   109k|  int i;
  264|       |
  265|   109k|  fe_sq(t0, z);
  266|   109k|  fe_sq(t1, t0);
  267|   109k|  fe_sq(t1, t1);
  268|   109k|  fe_mul(t1, z, t1);
  269|   109k|  fe_mul(t0, t0, t1);
  270|   109k|  fe_sq(t2, t0);
  271|   109k|  fe_mul(t1, t1, t2);
  272|   109k|  fe_sq(t2, t1);
  273|   549k|  for (i = 0; i < 4; ++i) {
  ------------------
  |  Branch (273:15): [True: 439k, False: 109k]
  ------------------
  274|   439k|    fe_sq(t2, t2);
  275|   439k|  }
  276|   109k|  fe_mul(t1, t2, t1);
  277|   109k|  fe_sq(t2, t1);
  278|  1.09M|  for (i = 0; i < 9; ++i) {
  ------------------
  |  Branch (278:15): [True: 989k, False: 109k]
  ------------------
  279|   989k|    fe_sq(t2, t2);
  280|   989k|  }
  281|   109k|  fe_mul(t2, t2, t1);
  282|   109k|  fe_sq(t3, t2);
  283|  2.19M|  for (i = 0; i < 19; ++i) {
  ------------------
  |  Branch (283:15): [True: 2.08M, False: 109k]
  ------------------
  284|  2.08M|    fe_sq(t3, t3);
  285|  2.08M|  }
  286|   109k|  fe_mul(t2, t3, t2);
  287|   109k|  fe_sq(t2, t2);
  288|  1.09M|  for (i = 0; i < 9; ++i) {
  ------------------
  |  Branch (288:15): [True: 989k, False: 109k]
  ------------------
  289|   989k|    fe_sq(t2, t2);
  290|   989k|  }
  291|   109k|  fe_mul(t1, t2, t1);
  292|   109k|  fe_sq(t2, t1);
  293|  5.49M|  for (i = 0; i < 49; ++i) {
  ------------------
  |  Branch (293:15): [True: 5.38M, False: 109k]
  ------------------
  294|  5.38M|    fe_sq(t2, t2);
  295|  5.38M|  }
  296|   109k|  fe_mul(t2, t2, t1);
  297|   109k|  fe_sq(t3, t2);
  298|  10.9M|  for (i = 0; i < 99; ++i) {
  ------------------
  |  Branch (298:15): [True: 10.8M, False: 109k]
  ------------------
  299|  10.8M|    fe_sq(t3, t3);
  300|  10.8M|  }
  301|   109k|  fe_mul(t2, t3, t2);
  302|   109k|  fe_sq(t2, t2);
  303|  5.49M|  for (i = 0; i < 49; ++i) {
  ------------------
  |  Branch (303:15): [True: 5.38M, False: 109k]
  ------------------
  304|  5.38M|    fe_sq(t2, t2);
  305|  5.38M|  }
  306|   109k|  fe_mul(t1, t2, t1);
  307|   109k|  fe_sq(t1, t1);
  308|   549k|  for (i = 0; i < 4; ++i) {
  ------------------
  |  Branch (308:15): [True: 439k, False: 109k]
  ------------------
  309|   439k|    fe_sq(t1, t1);
  310|   439k|  }
  311|   109k|  fe_mul(out, t1, t0);
  312|       |
  313|   109k|  return;
  314|   109k|}
fe_mul:
  377|  52.0M|void fe_mul(fe h, const fe f, const fe g) {
  378|  52.0M|  int32_t f0 = f[0];
  379|  52.0M|  int32_t f1 = f[1];
  380|  52.0M|  int32_t f2 = f[2];
  381|  52.0M|  int32_t f3 = f[3];
  382|  52.0M|  int32_t f4 = f[4];
  383|  52.0M|  int32_t f5 = f[5];
  384|  52.0M|  int32_t f6 = f[6];
  385|  52.0M|  int32_t f7 = f[7];
  386|  52.0M|  int32_t f8 = f[8];
  387|  52.0M|  int32_t f9 = f[9];
  388|  52.0M|  int32_t g0 = g[0];
  389|  52.0M|  int32_t g1 = g[1];
  390|  52.0M|  int32_t g2 = g[2];
  391|  52.0M|  int32_t g3 = g[3];
  392|  52.0M|  int32_t g4 = g[4];
  393|  52.0M|  int32_t g5 = g[5];
  394|  52.0M|  int32_t g6 = g[6];
  395|  52.0M|  int32_t g7 = g[7];
  396|  52.0M|  int32_t g8 = g[8];
  397|  52.0M|  int32_t g9 = g[9];
  398|  52.0M|  int32_t g1_19 = 19 * g1; /* 1.959375*2^29 */
  399|  52.0M|  int32_t g2_19 = 19 * g2; /* 1.959375*2^30; still ok */
  400|  52.0M|  int32_t g3_19 = 19 * g3;
  401|  52.0M|  int32_t g4_19 = 19 * g4;
  402|  52.0M|  int32_t g5_19 = 19 * g5;
  403|  52.0M|  int32_t g6_19 = 19 * g6;
  404|  52.0M|  int32_t g7_19 = 19 * g7;
  405|  52.0M|  int32_t g8_19 = 19 * g8;
  406|  52.0M|  int32_t g9_19 = 19 * g9;
  407|  52.0M|  int32_t f1_2 = 2 * f1;
  408|  52.0M|  int32_t f3_2 = 2 * f3;
  409|  52.0M|  int32_t f5_2 = 2 * f5;
  410|  52.0M|  int32_t f7_2 = 2 * f7;
  411|  52.0M|  int32_t f9_2 = 2 * f9;
  412|  52.0M|  int64_t f0g0    = f0   * (int64_t) g0;
  413|  52.0M|  int64_t f0g1    = f0   * (int64_t) g1;
  414|  52.0M|  int64_t f0g2    = f0   * (int64_t) g2;
  415|  52.0M|  int64_t f0g3    = f0   * (int64_t) g3;
  416|  52.0M|  int64_t f0g4    = f0   * (int64_t) g4;
  417|  52.0M|  int64_t f0g5    = f0   * (int64_t) g5;
  418|  52.0M|  int64_t f0g6    = f0   * (int64_t) g6;
  419|  52.0M|  int64_t f0g7    = f0   * (int64_t) g7;
  420|  52.0M|  int64_t f0g8    = f0   * (int64_t) g8;
  421|  52.0M|  int64_t f0g9    = f0   * (int64_t) g9;
  422|  52.0M|  int64_t f1g0    = f1   * (int64_t) g0;
  423|  52.0M|  int64_t f1g1_2  = f1_2 * (int64_t) g1;
  424|  52.0M|  int64_t f1g2    = f1   * (int64_t) g2;
  425|  52.0M|  int64_t f1g3_2  = f1_2 * (int64_t) g3;
  426|  52.0M|  int64_t f1g4    = f1   * (int64_t) g4;
  427|  52.0M|  int64_t f1g5_2  = f1_2 * (int64_t) g5;
  428|  52.0M|  int64_t f1g6    = f1   * (int64_t) g6;
  429|  52.0M|  int64_t f1g7_2  = f1_2 * (int64_t) g7;
  430|  52.0M|  int64_t f1g8    = f1   * (int64_t) g8;
  431|  52.0M|  int64_t f1g9_38 = f1_2 * (int64_t) g9_19;
  432|  52.0M|  int64_t f2g0    = f2   * (int64_t) g0;
  433|  52.0M|  int64_t f2g1    = f2   * (int64_t) g1;
  434|  52.0M|  int64_t f2g2    = f2   * (int64_t) g2;
  435|  52.0M|  int64_t f2g3    = f2   * (int64_t) g3;
  436|  52.0M|  int64_t f2g4    = f2   * (int64_t) g4;
  437|  52.0M|  int64_t f2g5    = f2   * (int64_t) g5;
  438|  52.0M|  int64_t f2g6    = f2   * (int64_t) g6;
  439|  52.0M|  int64_t f2g7    = f2   * (int64_t) g7;
  440|  52.0M|  int64_t f2g8_19 = f2   * (int64_t) g8_19;
  441|  52.0M|  int64_t f2g9_19 = f2   * (int64_t) g9_19;
  442|  52.0M|  int64_t f3g0    = f3   * (int64_t) g0;
  443|  52.0M|  int64_t f3g1_2  = f3_2 * (int64_t) g1;
  444|  52.0M|  int64_t f3g2    = f3   * (int64_t) g2;
  445|  52.0M|  int64_t f3g3_2  = f3_2 * (int64_t) g3;
  446|  52.0M|  int64_t f3g4    = f3   * (int64_t) g4;
  447|  52.0M|  int64_t f3g5_2  = f3_2 * (int64_t) g5;
  448|  52.0M|  int64_t f3g6    = f3   * (int64_t) g6;
  449|  52.0M|  int64_t f3g7_38 = f3_2 * (int64_t) g7_19;
  450|  52.0M|  int64_t f3g8_19 = f3   * (int64_t) g8_19;
  451|  52.0M|  int64_t f3g9_38 = f3_2 * (int64_t) g9_19;
  452|  52.0M|  int64_t f4g0    = f4   * (int64_t) g0;
  453|  52.0M|  int64_t f4g1    = f4   * (int64_t) g1;
  454|  52.0M|  int64_t f4g2    = f4   * (int64_t) g2;
  455|  52.0M|  int64_t f4g3    = f4   * (int64_t) g3;
  456|  52.0M|  int64_t f4g4    = f4   * (int64_t) g4;
  457|  52.0M|  int64_t f4g5    = f4   * (int64_t) g5;
  458|  52.0M|  int64_t f4g6_19 = f4   * (int64_t) g6_19;
  459|  52.0M|  int64_t f4g7_19 = f4   * (int64_t) g7_19;
  460|  52.0M|  int64_t f4g8_19 = f4   * (int64_t) g8_19;
  461|  52.0M|  int64_t f4g9_19 = f4   * (int64_t) g9_19;
  462|  52.0M|  int64_t f5g0    = f5   * (int64_t) g0;
  463|  52.0M|  int64_t f5g1_2  = f5_2 * (int64_t) g1;
  464|  52.0M|  int64_t f5g2    = f5   * (int64_t) g2;
  465|  52.0M|  int64_t f5g3_2  = f5_2 * (int64_t) g3;
  466|  52.0M|  int64_t f5g4    = f5   * (int64_t) g4;
  467|  52.0M|  int64_t f5g5_38 = f5_2 * (int64_t) g5_19;
  468|  52.0M|  int64_t f5g6_19 = f5   * (int64_t) g6_19;
  469|  52.0M|  int64_t f5g7_38 = f5_2 * (int64_t) g7_19;
  470|  52.0M|  int64_t f5g8_19 = f5   * (int64_t) g8_19;
  471|  52.0M|  int64_t f5g9_38 = f5_2 * (int64_t) g9_19;
  472|  52.0M|  int64_t f6g0    = f6   * (int64_t) g0;
  473|  52.0M|  int64_t f6g1    = f6   * (int64_t) g1;
  474|  52.0M|  int64_t f6g2    = f6   * (int64_t) g2;
  475|  52.0M|  int64_t f6g3    = f6   * (int64_t) g3;
  476|  52.0M|  int64_t f6g4_19 = f6   * (int64_t) g4_19;
  477|  52.0M|  int64_t f6g5_19 = f6   * (int64_t) g5_19;
  478|  52.0M|  int64_t f6g6_19 = f6   * (int64_t) g6_19;
  479|  52.0M|  int64_t f6g7_19 = f6   * (int64_t) g7_19;
  480|  52.0M|  int64_t f6g8_19 = f6   * (int64_t) g8_19;
  481|  52.0M|  int64_t f6g9_19 = f6   * (int64_t) g9_19;
  482|  52.0M|  int64_t f7g0    = f7   * (int64_t) g0;
  483|  52.0M|  int64_t f7g1_2  = f7_2 * (int64_t) g1;
  484|  52.0M|  int64_t f7g2    = f7   * (int64_t) g2;
  485|  52.0M|  int64_t f7g3_38 = f7_2 * (int64_t) g3_19;
  486|  52.0M|  int64_t f7g4_19 = f7   * (int64_t) g4_19;
  487|  52.0M|  int64_t f7g5_38 = f7_2 * (int64_t) g5_19;
  488|  52.0M|  int64_t f7g6_19 = f7   * (int64_t) g6_19;
  489|  52.0M|  int64_t f7g7_38 = f7_2 * (int64_t) g7_19;
  490|  52.0M|  int64_t f7g8_19 = f7   * (int64_t) g8_19;
  491|  52.0M|  int64_t f7g9_38 = f7_2 * (int64_t) g9_19;
  492|  52.0M|  int64_t f8g0    = f8   * (int64_t) g0;
  493|  52.0M|  int64_t f8g1    = f8   * (int64_t) g1;
  494|  52.0M|  int64_t f8g2_19 = f8   * (int64_t) g2_19;
  495|  52.0M|  int64_t f8g3_19 = f8   * (int64_t) g3_19;
  496|  52.0M|  int64_t f8g4_19 = f8   * (int64_t) g4_19;
  497|  52.0M|  int64_t f8g5_19 = f8   * (int64_t) g5_19;
  498|  52.0M|  int64_t f8g6_19 = f8   * (int64_t) g6_19;
  499|  52.0M|  int64_t f8g7_19 = f8   * (int64_t) g7_19;
  500|  52.0M|  int64_t f8g8_19 = f8   * (int64_t) g8_19;
  501|  52.0M|  int64_t f8g9_19 = f8   * (int64_t) g9_19;
  502|  52.0M|  int64_t f9g0    = f9   * (int64_t) g0;
  503|  52.0M|  int64_t f9g1_38 = f9_2 * (int64_t) g1_19;
  504|  52.0M|  int64_t f9g2_19 = f9   * (int64_t) g2_19;
  505|  52.0M|  int64_t f9g3_38 = f9_2 * (int64_t) g3_19;
  506|  52.0M|  int64_t f9g4_19 = f9   * (int64_t) g4_19;
  507|  52.0M|  int64_t f9g5_38 = f9_2 * (int64_t) g5_19;
  508|  52.0M|  int64_t f9g6_19 = f9   * (int64_t) g6_19;
  509|  52.0M|  int64_t f9g7_38 = f9_2 * (int64_t) g7_19;
  510|  52.0M|  int64_t f9g8_19 = f9   * (int64_t) g8_19;
  511|  52.0M|  int64_t f9g9_38 = f9_2 * (int64_t) g9_19;
  512|  52.0M|  int64_t h0 = f0g0+f1g9_38+f2g8_19+f3g7_38+f4g6_19+f5g5_38+f6g4_19+f7g3_38+f8g2_19+f9g1_38;
  513|  52.0M|  int64_t h1 = f0g1+f1g0   +f2g9_19+f3g8_19+f4g7_19+f5g6_19+f6g5_19+f7g4_19+f8g3_19+f9g2_19;
  514|  52.0M|  int64_t h2 = f0g2+f1g1_2 +f2g0   +f3g9_38+f4g8_19+f5g7_38+f6g6_19+f7g5_38+f8g4_19+f9g3_38;
  515|  52.0M|  int64_t h3 = f0g3+f1g2   +f2g1   +f3g0   +f4g9_19+f5g8_19+f6g7_19+f7g6_19+f8g5_19+f9g4_19;
  516|  52.0M|  int64_t h4 = f0g4+f1g3_2 +f2g2   +f3g1_2 +f4g0   +f5g9_38+f6g8_19+f7g7_38+f8g6_19+f9g5_38;
  517|  52.0M|  int64_t h5 = f0g5+f1g4   +f2g3   +f3g2   +f4g1   +f5g0   +f6g9_19+f7g8_19+f8g7_19+f9g6_19;
  518|  52.0M|  int64_t h6 = f0g6+f1g5_2 +f2g4   +f3g3_2 +f4g2   +f5g1_2 +f6g0   +f7g9_38+f8g8_19+f9g7_38;
  519|  52.0M|  int64_t h7 = f0g7+f1g6   +f2g5   +f3g4   +f4g3   +f5g2   +f6g1   +f7g0   +f8g9_19+f9g8_19;
  520|  52.0M|  int64_t h8 = f0g8+f1g7_2 +f2g6   +f3g5_2 +f4g4   +f5g3_2 +f6g2   +f7g1_2 +f8g0   +f9g9_38;
  521|  52.0M|  int64_t h9 = f0g9+f1g8   +f2g7   +f3g6   +f4g5   +f5g4   +f6g3   +f7g2   +f8g1   +f9g0   ;
  522|  52.0M|  int64_t carry0;
  523|  52.0M|  int64_t carry1;
  524|  52.0M|  int64_t carry2;
  525|  52.0M|  int64_t carry3;
  526|  52.0M|  int64_t carry4;
  527|  52.0M|  int64_t carry5;
  528|  52.0M|  int64_t carry6;
  529|  52.0M|  int64_t carry7;
  530|  52.0M|  int64_t carry8;
  531|  52.0M|  int64_t carry9;
  532|       |
  533|       |  /*
  534|       |  |h0| <= (1.65*1.65*2^52*(1+19+19+19+19)+1.65*1.65*2^50*(38+38+38+38+38))
  535|       |    i.e. |h0| <= 1.4*2^60; narrower ranges for h2, h4, h6, h8
  536|       |  |h1| <= (1.65*1.65*2^51*(1+1+19+19+19+19+19+19+19+19))
  537|       |    i.e. |h1| <= 1.7*2^59; narrower ranges for h3, h5, h7, h9
  538|       |  */
  539|       |
  540|  52.0M|  carry0 = (h0 + (int64_t) (1<<25)) >> 26; h1 += carry0; h0 -= carry0 << 26;
  541|  52.0M|  carry4 = (h4 + (int64_t) (1<<25)) >> 26; h5 += carry4; h4 -= carry4 << 26;
  542|       |  /* |h0| <= 2^25 */
  543|       |  /* |h4| <= 2^25 */
  544|       |  /* |h1| <= 1.71*2^59 */
  545|       |  /* |h5| <= 1.71*2^59 */
  546|       |
  547|  52.0M|  carry1 = (h1 + (int64_t) (1<<24)) >> 25; h2 += carry1; h1 -= carry1 << 25;
  548|  52.0M|  carry5 = (h5 + (int64_t) (1<<24)) >> 25; h6 += carry5; h5 -= carry5 << 25;
  549|       |  /* |h1| <= 2^24; from now on fits into int32 */
  550|       |  /* |h5| <= 2^24; from now on fits into int32 */
  551|       |  /* |h2| <= 1.41*2^60 */
  552|       |  /* |h6| <= 1.41*2^60 */
  553|       |
  554|  52.0M|  carry2 = (h2 + (int64_t) (1<<25)) >> 26; h3 += carry2; h2 -= carry2 << 26;
  555|  52.0M|  carry6 = (h6 + (int64_t) (1<<25)) >> 26; h7 += carry6; h6 -= carry6 << 26;
  556|       |  /* |h2| <= 2^25; from now on fits into int32 unchanged */
  557|       |  /* |h6| <= 2^25; from now on fits into int32 unchanged */
  558|       |  /* |h3| <= 1.71*2^59 */
  559|       |  /* |h7| <= 1.71*2^59 */
  560|       |
  561|  52.0M|  carry3 = (h3 + (int64_t) (1<<24)) >> 25; h4 += carry3; h3 -= carry3 << 25;
  562|  52.0M|  carry7 = (h7 + (int64_t) (1<<24)) >> 25; h8 += carry7; h7 -= carry7 << 25;
  563|       |  /* |h3| <= 2^24; from now on fits into int32 unchanged */
  564|       |  /* |h7| <= 2^24; from now on fits into int32 unchanged */
  565|       |  /* |h4| <= 1.72*2^34 */
  566|       |  /* |h8| <= 1.41*2^60 */
  567|       |
  568|  52.0M|  carry4 = (h4 + (int64_t) (1<<25)) >> 26; h5 += carry4; h4 -= carry4 << 26;
  569|  52.0M|  carry8 = (h8 + (int64_t) (1<<25)) >> 26; h9 += carry8; h8 -= carry8 << 26;
  570|       |  /* |h4| <= 2^25; from now on fits into int32 unchanged */
  571|       |  /* |h8| <= 2^25; from now on fits into int32 unchanged */
  572|       |  /* |h5| <= 1.01*2^24 */
  573|       |  /* |h9| <= 1.71*2^59 */
  574|       |
  575|  52.0M|  carry9 = (h9 + (int64_t) (1<<24)) >> 25; h0 += carry9 * 19; h9 -= carry9 << 25;
  576|       |  /* |h9| <= 2^24; from now on fits into int32 unchanged */
  577|       |  /* |h0| <= 1.1*2^39 */
  578|       |
  579|  52.0M|  carry0 = (h0 + (int64_t) (1<<25)) >> 26; h1 += carry0; h0 -= carry0 << 26;
  580|       |  /* |h0| <= 2^25; from now on fits into int32 unchanged */
  581|       |  /* |h1| <= 1.01*2^24 */
  582|       |
  583|  52.0M|  h[0] = h0;
  584|  52.0M|  h[1] = h1;
  585|  52.0M|  h[2] = h2;
  586|  52.0M|  h[3] = h3;
  587|  52.0M|  h[4] = h4;
  588|  52.0M|  h[5] = h5;
  589|  52.0M|  h[6] = h6;
  590|  52.0M|  h[7] = h7;
  591|  52.0M|  h[8] = h8;
  592|  52.0M|  h[9] = h9;
  593|  52.0M|}
fe_tobytes:
 1031|   221k|void fe_tobytes(unsigned char *s, const fe h) {
 1032|   221k|  int32_t h0 = h[0];
 1033|   221k|  int32_t h1 = h[1];
 1034|   221k|  int32_t h2 = h[2];
 1035|   221k|  int32_t h3 = h[3];
 1036|   221k|  int32_t h4 = h[4];
 1037|   221k|  int32_t h5 = h[5];
 1038|   221k|  int32_t h6 = h[6];
 1039|   221k|  int32_t h7 = h[7];
 1040|   221k|  int32_t h8 = h[8];
 1041|   221k|  int32_t h9 = h[9];
 1042|   221k|  int32_t q;
 1043|   221k|  int32_t carry0;
 1044|   221k|  int32_t carry1;
 1045|   221k|  int32_t carry2;
 1046|   221k|  int32_t carry3;
 1047|   221k|  int32_t carry4;
 1048|   221k|  int32_t carry5;
 1049|   221k|  int32_t carry6;
 1050|   221k|  int32_t carry7;
 1051|   221k|  int32_t carry8;
 1052|   221k|  int32_t carry9;
 1053|       |
 1054|   221k|  q = (19 * h9 + (((int32_t) 1) << 24)) >> 25;
 1055|   221k|  q = (h0 + q) >> 26;
 1056|   221k|  q = (h1 + q) >> 25;
 1057|   221k|  q = (h2 + q) >> 26;
 1058|   221k|  q = (h3 + q) >> 25;
 1059|   221k|  q = (h4 + q) >> 26;
 1060|   221k|  q = (h5 + q) >> 25;
 1061|   221k|  q = (h6 + q) >> 26;
 1062|   221k|  q = (h7 + q) >> 25;
 1063|   221k|  q = (h8 + q) >> 26;
 1064|   221k|  q = (h9 + q) >> 25;
 1065|       |
 1066|       |  /* Goal: Output h-(2^255-19)q, which is between 0 and 2^255-20. */
 1067|   221k|  h0 += 19 * q;
 1068|       |  /* Goal: Output h-2^255 q, which is between 0 and 2^255-20. */
 1069|       |
 1070|   221k|  carry0 = h0 >> 26; h1 += carry0; h0 -= carry0 << 26;
 1071|   221k|  carry1 = h1 >> 25; h2 += carry1; h1 -= carry1 << 25;
 1072|   221k|  carry2 = h2 >> 26; h3 += carry2; h2 -= carry2 << 26;
 1073|   221k|  carry3 = h3 >> 25; h4 += carry3; h3 -= carry3 << 25;
 1074|   221k|  carry4 = h4 >> 26; h5 += carry4; h4 -= carry4 << 26;
 1075|   221k|  carry5 = h5 >> 25; h6 += carry5; h5 -= carry5 << 25;
 1076|   221k|  carry6 = h6 >> 26; h7 += carry6; h6 -= carry6 << 26;
 1077|   221k|  carry7 = h7 >> 25; h8 += carry7; h7 -= carry7 << 25;
 1078|   221k|  carry8 = h8 >> 26; h9 += carry8; h8 -= carry8 << 26;
 1079|   221k|  carry9 = h9 >> 25;               h9 -= carry9 << 25;
 1080|       |                  /* h10 = carry9 */
 1081|       |
 1082|       |  /*
 1083|       |  Goal: Output h0+...+2^255 h10-2^255 q, which is between 0 and 2^255-20.
 1084|       |  Have h0+...+2^230 h9 between 0 and 2^255-1;
 1085|       |  evidently 2^255 h10-2^255 q = 0.
 1086|       |  Goal: Output h0+...+2^230 h9.
 1087|       |  */
 1088|       |
 1089|   221k|  s[0] = h0 >> 0;
 1090|   221k|  s[1] = h0 >> 8;
 1091|   221k|  s[2] = h0 >> 16;
 1092|   221k|  s[3] = (h0 >> 24) | (h1 << 2);
 1093|   221k|  s[4] = h1 >> 6;
 1094|   221k|  s[5] = h1 >> 14;
 1095|   221k|  s[6] = (h1 >> 22) | (h2 << 3);
 1096|   221k|  s[7] = h2 >> 5;
 1097|   221k|  s[8] = h2 >> 13;
 1098|   221k|  s[9] = (h2 >> 21) | (h3 << 5);
 1099|   221k|  s[10] = h3 >> 3;
 1100|   221k|  s[11] = h3 >> 11;
 1101|   221k|  s[12] = (h3 >> 19) | (h4 << 6);
 1102|   221k|  s[13] = h4 >> 2;
 1103|   221k|  s[14] = h4 >> 10;
 1104|   221k|  s[15] = h4 >> 18;
 1105|   221k|  s[16] = h5 >> 0;
 1106|   221k|  s[17] = h5 >> 8;
 1107|   221k|  s[18] = h5 >> 16;
 1108|   221k|  s[19] = (h5 >> 24) | (h6 << 1);
 1109|   221k|  s[20] = h6 >> 7;
 1110|   221k|  s[21] = h6 >> 15;
 1111|   221k|  s[22] = (h6 >> 23) | (h7 << 3);
 1112|   221k|  s[23] = h7 >> 5;
 1113|   221k|  s[24] = h7 >> 13;
 1114|   221k|  s[25] = (h7 >> 21) | (h8 << 4);
 1115|   221k|  s[26] = h8 >> 4;
 1116|   221k|  s[27] = h8 >> 12;
 1117|   221k|  s[28] = (h8 >> 20) | (h9 << 6);
 1118|   221k|  s[29] = h9 >> 2;
 1119|   221k|  s[30] = h9 >> 10;
 1120|   221k|  s[31] = h9 >> 18;
 1121|   221k|}
ge_add:
 1125|    276|void ge_add(ge_p1p1 *r, const ge_p3 *p, const ge_cached *q) {
 1126|    276|  fe t0;
 1127|    276|  fe_add(r->X, p->Y, p->X);
 1128|    276|  fe_sub(r->Y, p->Y, p->X);
 1129|    276|  fe_mul(r->Z, r->X, q->YplusX);
 1130|    276|  fe_mul(r->Y, r->Y, q->YminusX);
 1131|    276|  fe_mul(r->T, q->T2d, p->T);
 1132|    276|  fe_mul(r->X, p->Z, q->Z);
 1133|    276|  fe_add(t0, r->X, r->X);
 1134|    276|  fe_sub(r->X, r->Z, r->Y);
 1135|    276|  fe_add(r->Y, r->Z, r->Y);
 1136|    276|  fe_add(r->Z, t0, r->T);
 1137|    276|  fe_sub(r->T, t0, r->T);
 1138|    276|}
ge_frombytes_vartime:
 1333|    553|int ge_frombytes_vartime(ge_p3 *h, const unsigned char *s) {
 1334|    553|  fe u;
 1335|    553|  fe v;
 1336|    553|  fe vxx;
 1337|    553|  fe check;
 1338|       |
 1339|       |  /* From fe_frombytes.c */
 1340|       |
 1341|    553|  int64_t h0 = load_4(s);
 1342|    553|  int64_t h1 = load_3(s + 4) << 6;
 1343|    553|  int64_t h2 = load_3(s + 7) << 5;
 1344|    553|  int64_t h3 = load_3(s + 10) << 3;
 1345|    553|  int64_t h4 = load_3(s + 13) << 2;
 1346|    553|  int64_t h5 = load_4(s + 16);
 1347|    553|  int64_t h6 = load_3(s + 20) << 7;
 1348|    553|  int64_t h7 = load_3(s + 23) << 5;
 1349|    553|  int64_t h8 = load_3(s + 26) << 4;
 1350|    553|  int64_t h9 = (load_3(s + 29) & 8388607) << 2;
 1351|    553|  int64_t carry0;
 1352|    553|  int64_t carry1;
 1353|    553|  int64_t carry2;
 1354|    553|  int64_t carry3;
 1355|    553|  int64_t carry4;
 1356|    553|  int64_t carry5;
 1357|    553|  int64_t carry6;
 1358|    553|  int64_t carry7;
 1359|    553|  int64_t carry8;
 1360|    553|  int64_t carry9;
 1361|       |
 1362|       |  /* Validate the number to be canonical */
 1363|    553|  if (h9 == 33554428 && h8 == 268435440 && h7 == 536870880 && h6 == 2147483520 &&
  ------------------
  |  Branch (1363:7): [True: 0, False: 553]
  |  Branch (1363:25): [True: 0, False: 0]
  |  Branch (1363:44): [True: 0, False: 0]
  |  Branch (1363:63): [True: 0, False: 0]
  ------------------
 1364|    553|    h5 == 4294967295 && h4 == 67108860 && h3 == 134217720 && h2 == 536870880 &&
  ------------------
  |  Branch (1364:5): [True: 0, False: 0]
  |  Branch (1364:25): [True: 0, False: 0]
  |  Branch (1364:43): [True: 0, False: 0]
  |  Branch (1364:62): [True: 0, False: 0]
  ------------------
 1365|    553|    h1 == 1073741760 && h0 >= 4294967277) {
  ------------------
  |  Branch (1365:5): [True: 0, False: 0]
  |  Branch (1365:25): [True: 0, False: 0]
  ------------------
 1366|      0|    return -1;
 1367|      0|  }
 1368|       |
 1369|    553|  carry9 = (h9 + (int64_t) (1<<24)) >> 25; h0 += carry9 * 19; h9 -= carry9 << 25;
 1370|    553|  carry1 = (h1 + (int64_t) (1<<24)) >> 25; h2 += carry1; h1 -= carry1 << 25;
 1371|    553|  carry3 = (h3 + (int64_t) (1<<24)) >> 25; h4 += carry3; h3 -= carry3 << 25;
 1372|    553|  carry5 = (h5 + (int64_t) (1<<24)) >> 25; h6 += carry5; h5 -= carry5 << 25;
 1373|    553|  carry7 = (h7 + (int64_t) (1<<24)) >> 25; h8 += carry7; h7 -= carry7 << 25;
 1374|       |
 1375|    553|  carry0 = (h0 + (int64_t) (1<<25)) >> 26; h1 += carry0; h0 -= carry0 << 26;
 1376|    553|  carry2 = (h2 + (int64_t) (1<<25)) >> 26; h3 += carry2; h2 -= carry2 << 26;
 1377|    553|  carry4 = (h4 + (int64_t) (1<<25)) >> 26; h5 += carry4; h4 -= carry4 << 26;
 1378|    553|  carry6 = (h6 + (int64_t) (1<<25)) >> 26; h7 += carry6; h6 -= carry6 << 26;
 1379|    553|  carry8 = (h8 + (int64_t) (1<<25)) >> 26; h9 += carry8; h8 -= carry8 << 26;
 1380|       |
 1381|    553|  h->Y[0] = h0;
 1382|    553|  h->Y[1] = h1;
 1383|    553|  h->Y[2] = h2;
 1384|    553|  h->Y[3] = h3;
 1385|    553|  h->Y[4] = h4;
 1386|    553|  h->Y[5] = h5;
 1387|    553|  h->Y[6] = h6;
 1388|    553|  h->Y[7] = h7;
 1389|    553|  h->Y[8] = h8;
 1390|    553|  h->Y[9] = h9;
 1391|       |
 1392|       |  /* End fe_frombytes.c */
 1393|       |
 1394|    553|  fe_1(h->Z);
 1395|    553|  fe_sq(u, h->Y);
 1396|    553|  fe_mul(v, u, fe_d);
 1397|    553|  fe_sub(u, u, h->Z);       /* u = y^2-1 */
 1398|    553|  fe_add(v, v, h->Z);       /* v = dy^2+1 */
 1399|       |
 1400|    553|  fe_divpowm1(h->X, u, v); /* x = uv^3(uv^7)^((q-5)/8) */
 1401|       |
 1402|    553|  fe_sq(vxx, h->X);
 1403|    553|  fe_mul(vxx, vxx, v);
 1404|    553|  fe_sub(check, vxx, u);    /* vx^2-u */
 1405|    553|  if (fe_isnonzero(check)) {
  ------------------
  |  Branch (1405:7): [True: 115, False: 438]
  ------------------
 1406|    115|    fe_add(check, vxx, u);  /* vx^2+u */
 1407|    115|    if (fe_isnonzero(check)) {
  ------------------
  |  Branch (1407:9): [True: 0, False: 115]
  ------------------
 1408|      0|      return -1;
 1409|      0|    }
 1410|    115|    fe_mul(h->X, h->X, fe_sqrtm1);
 1411|    115|  }
 1412|       |
 1413|    553|  if (fe_isnegative(h->X) != (s[31] >> 7)) {
  ------------------
  |  Branch (1413:7): [True: 405, False: 148]
  ------------------
 1414|       |    /* If x = 0, the sign must be positive */
 1415|    405|    if (!fe_isnonzero(h->X)) {
  ------------------
  |  Branch (1415:9): [True: 0, False: 405]
  ------------------
 1416|      0|      return -1;
 1417|      0|    }
 1418|    405|    fe_neg(h->X, h->X);
 1419|    405|  }
 1420|       |
 1421|    553|  fe_mul(h->T, h->X, h->Y);
 1422|    553|  return 0;
 1423|    553|}
ge_p1p1_to_p2:
 1471|   329k|void ge_p1p1_to_p2(ge_p2 *r, const ge_p1p1 *p) {
 1472|   329k|  fe_mul(r->X, p->X, p->T);
 1473|   329k|  fe_mul(r->Y, p->Y, p->Z);
 1474|   329k|  fe_mul(r->Z, p->Z, p->T);
 1475|   329k|}
ge_p1p1_to_p3:
 1483|  7.12M|void ge_p1p1_to_p3(ge_p3 *r, const ge_p1p1 *p) {
 1484|  7.12M|  fe_mul(r->X, p->X, p->T);
 1485|  7.12M|  fe_mul(r->Y, p->Y, p->Z);
 1486|  7.12M|  fe_mul(r->Z, p->Z, p->T);
 1487|  7.12M|  fe_mul(r->T, p->X, p->Y);
 1488|  7.12M|}
ge_p2_dbl:
 1504|   438k|void ge_p2_dbl(ge_p1p1 *r, const ge_p2 *p) {
 1505|   438k|  fe t0;
 1506|   438k|  fe_sq(r->X, p->X);
 1507|   438k|  fe_sq(r->Z, p->Y);
 1508|   438k|  fe_sq2(r->T, p->Z);
 1509|   438k|  fe_add(r->Y, p->X, p->Y);
 1510|   438k|  fe_sq(t0, r->Y);
 1511|   438k|  fe_add(r->Y, r->Z, r->X);
 1512|   438k|  fe_sub(r->Z, r->Z, r->X);
 1513|   438k|  fe_sub(r->X, t0, r->Y);
 1514|   438k|  fe_sub(r->T, r->T, r->Z);
 1515|   438k|}
ge_p3_to_cached:
 1544|    277|void ge_p3_to_cached(ge_cached *r, const ge_p3 *p) {
 1545|    277|  fe_add(r->YplusX, p->Y, p->X);
 1546|    277|  fe_sub(r->YminusX, p->Y, p->X);
 1547|    277|  fe_copy(r->Z, p->Z);
 1548|    277|  fe_mul(r->T2d, p->T, fe_d2);
 1549|    277|}
ge_p3_to_p2:
 1557|   109k|void ge_p3_to_p2(ge_p2 *r, const ge_p3 *p) {
 1558|   109k|  fe_copy(r->X, p->X);
 1559|   109k|  fe_copy(r->Y, p->Y);
 1560|   109k|  fe_copy(r->Z, p->Z);
 1561|   109k|}
ge_p3_tobytes:
 1565|   109k|void ge_p3_tobytes(unsigned char *s, const ge_p3 *h) {
 1566|   109k|  fe recip;
 1567|   109k|  fe x;
 1568|   109k|  fe y;
 1569|       |
 1570|   109k|  fe_invert(recip, h->Z);
 1571|   109k|  fe_mul(x, h->X, recip);
 1572|   109k|  fe_mul(y, h->Y, recip);
 1573|   109k|  fe_tobytes(s, y);
 1574|   109k|  s[31] ^= fe_isnegative(x) << 7;
 1575|   109k|}
ge_scalarmult_base:
 1638|   109k|void ge_scalarmult_base(ge_p3 *h, const unsigned char *a) {
 1639|   109k|  signed char e[64];
 1640|   109k|  signed char carry;
 1641|   109k|  ge_p1p1 r;
 1642|   109k|  ge_p2 s;
 1643|   109k|  ge_precomp t;
 1644|   109k|  int i;
 1645|       |
 1646|  3.61M|  for (i = 0; i < 32; ++i) {
  ------------------
  |  Branch (1646:15): [True: 3.50M, False: 109k]
  ------------------
 1647|  3.50M|    e[2 * i + 0] = (a[i] >> 0) & 15;
 1648|  3.50M|    e[2 * i + 1] = (a[i] >> 4) & 15;
 1649|  3.50M|  }
 1650|       |  /* each e[i] is between 0 and 15 */
 1651|       |  /* e[63] is between 0 and 7 */
 1652|       |
 1653|   109k|  carry = 0;
 1654|  7.01M|  for (i = 0; i < 63; ++i) {
  ------------------
  |  Branch (1654:15): [True: 6.90M, False: 109k]
  ------------------
 1655|  6.90M|    e[i] += carry;
 1656|  6.90M|    carry = e[i] + 8;
 1657|  6.90M|    carry >>= 4;
 1658|  6.90M|    e[i] -= carry << 4;
 1659|  6.90M|  }
 1660|   109k|  e[63] += carry;
 1661|       |  /* each e[i] is between -8 and 8 */
 1662|       |
 1663|   109k|  ge_p3_0(h);
 1664|  3.61M|  for (i = 1; i < 64; i += 2) {
  ------------------
  |  Branch (1664:15): [True: 3.50M, False: 109k]
  ------------------
 1665|  3.50M|    select(&t, i / 2, e[i]);
 1666|  3.50M|    ge_madd(&r, h, &t); ge_p1p1_to_p3(h, &r);
 1667|  3.50M|  }
 1668|       |
 1669|   109k|  ge_p3_dbl(&r, h);  ge_p1p1_to_p2(&s, &r);
 1670|   109k|  ge_p2_dbl(&r, &s); ge_p1p1_to_p2(&s, &r);
 1671|   109k|  ge_p2_dbl(&r, &s); ge_p1p1_to_p2(&s, &r);
 1672|   109k|  ge_p2_dbl(&r, &s); ge_p1p1_to_p3(h, &r);
 1673|       |
 1674|  3.61M|  for (i = 0; i < 64; i += 2) {
  ------------------
  |  Branch (1674:15): [True: 3.50M, False: 109k]
  ------------------
 1675|  3.50M|    select(&t, i / 2, e[i]);
 1676|  3.50M|    ge_madd(&r, h, &t); ge_p1p1_to_p3(h, &r);
 1677|  3.50M|  }
 1678|   109k|}
sc_reduce32:
 2432|   217k|void sc_reduce32(unsigned char *s) {
 2433|   217k|  int64_t s0 = 2097151 & load_3(s);
 2434|   217k|  int64_t s1 = 2097151 & (load_4(s + 2) >> 5);
 2435|   217k|  int64_t s2 = 2097151 & (load_3(s + 5) >> 2);
 2436|   217k|  int64_t s3 = 2097151 & (load_4(s + 7) >> 7);
 2437|   217k|  int64_t s4 = 2097151 & (load_4(s + 10) >> 4);
 2438|   217k|  int64_t s5 = 2097151 & (load_3(s + 13) >> 1);
 2439|   217k|  int64_t s6 = 2097151 & (load_4(s + 15) >> 6);
 2440|   217k|  int64_t s7 = 2097151 & (load_3(s + 18) >> 3);
 2441|   217k|  int64_t s8 = 2097151 & load_3(s + 21);
 2442|   217k|  int64_t s9 = 2097151 & (load_4(s + 23) >> 5);
 2443|   217k|  int64_t s10 = 2097151 & (load_3(s + 26) >> 2);
 2444|   217k|  int64_t s11 = (load_4(s + 28) >> 7);
 2445|   217k|  int64_t s12 = 0;
 2446|   217k|  int64_t carry0;
 2447|   217k|  int64_t carry1;
 2448|   217k|  int64_t carry2;
 2449|   217k|  int64_t carry3;
 2450|   217k|  int64_t carry4;
 2451|   217k|  int64_t carry5;
 2452|   217k|  int64_t carry6;
 2453|   217k|  int64_t carry7;
 2454|   217k|  int64_t carry8;
 2455|   217k|  int64_t carry9;
 2456|   217k|  int64_t carry10;
 2457|   217k|  int64_t carry11;
 2458|       |
 2459|   217k|  carry0 = (s0 + (1<<20)) >> 21; s1 += carry0; s0 -= carry0 << 21;
 2460|   217k|  carry2 = (s2 + (1<<20)) >> 21; s3 += carry2; s2 -= carry2 << 21;
 2461|   217k|  carry4 = (s4 + (1<<20)) >> 21; s5 += carry4; s4 -= carry4 << 21;
 2462|   217k|  carry6 = (s6 + (1<<20)) >> 21; s7 += carry6; s6 -= carry6 << 21;
 2463|   217k|  carry8 = (s8 + (1<<20)) >> 21; s9 += carry8; s8 -= carry8 << 21;
 2464|   217k|  carry10 = (s10 + (1<<20)) >> 21; s11 += carry10; s10 -= carry10 << 21;
 2465|       |
 2466|   217k|  carry1 = (s1 + (1<<20)) >> 21; s2 += carry1; s1 -= carry1 << 21;
 2467|   217k|  carry3 = (s3 + (1<<20)) >> 21; s4 += carry3; s3 -= carry3 << 21;
 2468|   217k|  carry5 = (s5 + (1<<20)) >> 21; s6 += carry5; s5 -= carry5 << 21;
 2469|   217k|  carry7 = (s7 + (1<<20)) >> 21; s8 += carry7; s7 -= carry7 << 21;
 2470|   217k|  carry9 = (s9 + (1<<20)) >> 21; s10 += carry9; s9 -= carry9 << 21;
 2471|   217k|  carry11 = (s11 + (1<<20)) >> 21; s12 += carry11; s11 -= carry11 << 21;
 2472|       |
 2473|   217k|  s0 += s12 * 666643;
 2474|   217k|  s1 += s12 * 470296;
 2475|   217k|  s2 += s12 * 654183;
 2476|   217k|  s3 -= s12 * 997805;
 2477|   217k|  s4 += s12 * 136657;
 2478|   217k|  s5 -= s12 * 683901;
 2479|   217k|  s12 = 0;
 2480|       |
 2481|   217k|  carry0 = s0 >> 21; s1 += carry0; s0 -= carry0 << 21;
 2482|   217k|  carry1 = s1 >> 21; s2 += carry1; s1 -= carry1 << 21;
 2483|   217k|  carry2 = s2 >> 21; s3 += carry2; s2 -= carry2 << 21;
 2484|   217k|  carry3 = s3 >> 21; s4 += carry3; s3 -= carry3 << 21;
 2485|   217k|  carry4 = s4 >> 21; s5 += carry4; s4 -= carry4 << 21;
 2486|   217k|  carry5 = s5 >> 21; s6 += carry5; s5 -= carry5 << 21;
 2487|   217k|  carry6 = s6 >> 21; s7 += carry6; s6 -= carry6 << 21;
 2488|   217k|  carry7 = s7 >> 21; s8 += carry7; s7 -= carry7 << 21;
 2489|   217k|  carry8 = s8 >> 21; s9 += carry8; s8 -= carry8 << 21;
 2490|   217k|  carry9 = s9 >> 21; s10 += carry9; s9 -= carry9 << 21;
 2491|   217k|  carry10 = s10 >> 21; s11 += carry10; s10 -= carry10 << 21;
 2492|   217k|  carry11 = s11 >> 21; s12 += carry11; s11 -= carry11 << 21;
 2493|       |
 2494|   217k|  s0 += s12 * 666643;
 2495|   217k|  s1 += s12 * 470296;
 2496|   217k|  s2 += s12 * 654183;
 2497|   217k|  s3 -= s12 * 997805;
 2498|   217k|  s4 += s12 * 136657;
 2499|   217k|  s5 -= s12 * 683901;
 2500|       |
 2501|   217k|  carry0 = s0 >> 21; s1 += carry0; s0 -= carry0 << 21;
 2502|   217k|  carry1 = s1 >> 21; s2 += carry1; s1 -= carry1 << 21;
 2503|   217k|  carry2 = s2 >> 21; s3 += carry2; s2 -= carry2 << 21;
 2504|   217k|  carry3 = s3 >> 21; s4 += carry3; s3 -= carry3 << 21;
 2505|   217k|  carry4 = s4 >> 21; s5 += carry4; s4 -= carry4 << 21;
 2506|   217k|  carry5 = s5 >> 21; s6 += carry5; s5 -= carry5 << 21;
 2507|   217k|  carry6 = s6 >> 21; s7 += carry6; s6 -= carry6 << 21;
 2508|   217k|  carry7 = s7 >> 21; s8 += carry7; s7 -= carry7 << 21;
 2509|   217k|  carry8 = s8 >> 21; s9 += carry8; s8 -= carry8 << 21;
 2510|   217k|  carry9 = s9 >> 21; s10 += carry9; s9 -= carry9 << 21;
 2511|   217k|  carry10 = s10 >> 21; s11 += carry10; s10 -= carry10 << 21;
 2512|       |
 2513|   217k|  s[0] = s0 >> 0;
 2514|   217k|  s[1] = s0 >> 8;
 2515|   217k|  s[2] = (s0 >> 16) | (s1 << 5);
 2516|   217k|  s[3] = s1 >> 3;
 2517|   217k|  s[4] = s1 >> 11;
 2518|   217k|  s[5] = (s1 >> 19) | (s2 << 2);
 2519|   217k|  s[6] = s2 >> 6;
 2520|   217k|  s[7] = (s2 >> 14) | (s3 << 7);
 2521|   217k|  s[8] = s3 >> 1;
 2522|   217k|  s[9] = s3 >> 9;
 2523|   217k|  s[10] = (s3 >> 17) | (s4 << 4);
 2524|   217k|  s[11] = s4 >> 4;
 2525|   217k|  s[12] = s4 >> 12;
 2526|   217k|  s[13] = (s4 >> 20) | (s5 << 1);
 2527|   217k|  s[14] = s5 >> 7;
 2528|   217k|  s[15] = (s5 >> 15) | (s6 << 6);
 2529|   217k|  s[16] = s6 >> 2;
 2530|   217k|  s[17] = s6 >> 10;
 2531|   217k|  s[18] = (s6 >> 18) | (s7 << 3);
 2532|   217k|  s[19] = s7 >> 5;
 2533|   217k|  s[20] = s7 >> 13;
 2534|   217k|  s[21] = s8 >> 0;
 2535|   217k|  s[22] = s8 >> 8;
 2536|   217k|  s[23] = (s8 >> 16) | (s9 << 5);
 2537|   217k|  s[24] = s9 >> 3;
 2538|   217k|  s[25] = s9 >> 11;
 2539|   217k|  s[26] = (s9 >> 19) | (s10 << 2);
 2540|   217k|  s[27] = s10 >> 6;
 2541|   217k|  s[28] = (s10 >> 14) | (s11 << 7);
 2542|   217k|  s[29] = s11 >> 1;
 2543|   217k|  s[30] = s11 >> 9;
 2544|   217k|  s[31] = s11 >> 17;
 2545|   217k|}
sc_add:
 2547|      1|void sc_add(unsigned char *s, const unsigned char *a, const unsigned char *b) {
 2548|      1|  int64_t a0 = 2097151 & load_3(a);
 2549|      1|  int64_t a1 = 2097151 & (load_4(a + 2) >> 5);
 2550|      1|  int64_t a2 = 2097151 & (load_3(a + 5) >> 2);
 2551|      1|  int64_t a3 = 2097151 & (load_4(a + 7) >> 7);
 2552|      1|  int64_t a4 = 2097151 & (load_4(a + 10) >> 4);
 2553|      1|  int64_t a5 = 2097151 & (load_3(a + 13) >> 1);
 2554|      1|  int64_t a6 = 2097151 & (load_4(a + 15) >> 6);
 2555|      1|  int64_t a7 = 2097151 & (load_3(a + 18) >> 3);
 2556|      1|  int64_t a8 = 2097151 & load_3(a + 21);
 2557|      1|  int64_t a9 = 2097151 & (load_4(a + 23) >> 5);
 2558|      1|  int64_t a10 = 2097151 & (load_3(a + 26) >> 2);
 2559|      1|  int64_t a11 = (load_4(a + 28) >> 7);
 2560|      1|  int64_t b0 = 2097151 & load_3(b);
 2561|      1|  int64_t b1 = 2097151 & (load_4(b + 2) >> 5);
 2562|      1|  int64_t b2 = 2097151 & (load_3(b + 5) >> 2);
 2563|      1|  int64_t b3 = 2097151 & (load_4(b + 7) >> 7);
 2564|      1|  int64_t b4 = 2097151 & (load_4(b + 10) >> 4);
 2565|      1|  int64_t b5 = 2097151 & (load_3(b + 13) >> 1);
 2566|      1|  int64_t b6 = 2097151 & (load_4(b + 15) >> 6);
 2567|      1|  int64_t b7 = 2097151 & (load_3(b + 18) >> 3);
 2568|      1|  int64_t b8 = 2097151 & load_3(b + 21);
 2569|      1|  int64_t b9 = 2097151 & (load_4(b + 23) >> 5);
 2570|      1|  int64_t b10 = 2097151 & (load_3(b + 26) >> 2);
 2571|      1|  int64_t b11 = (load_4(b + 28) >> 7);
 2572|      1|  int64_t s0 = a0 + b0;
 2573|      1|  int64_t s1 = a1 + b1;
 2574|      1|  int64_t s2 = a2 + b2;
 2575|      1|  int64_t s3 = a3 + b3;
 2576|      1|  int64_t s4 = a4 + b4;
 2577|      1|  int64_t s5 = a5 + b5;
 2578|      1|  int64_t s6 = a6 + b6;
 2579|      1|  int64_t s7 = a7 + b7;
 2580|      1|  int64_t s8 = a8 + b8;
 2581|      1|  int64_t s9 = a9 + b9;
 2582|      1|  int64_t s10 = a10 + b10;
 2583|      1|  int64_t s11 = a11 + b11;
 2584|      1|  int64_t s12 = 0;
 2585|      1|  int64_t carry0;
 2586|      1|  int64_t carry1;
 2587|      1|  int64_t carry2;
 2588|      1|  int64_t carry3;
 2589|      1|  int64_t carry4;
 2590|      1|  int64_t carry5;
 2591|      1|  int64_t carry6;
 2592|      1|  int64_t carry7;
 2593|      1|  int64_t carry8;
 2594|      1|  int64_t carry9;
 2595|      1|  int64_t carry10;
 2596|      1|  int64_t carry11;
 2597|       |
 2598|      1|  carry0 = (s0 + (1<<20)) >> 21; s1 += carry0; s0 -= carry0 << 21;
 2599|      1|  carry2 = (s2 + (1<<20)) >> 21; s3 += carry2; s2 -= carry2 << 21;
 2600|      1|  carry4 = (s4 + (1<<20)) >> 21; s5 += carry4; s4 -= carry4 << 21;
 2601|      1|  carry6 = (s6 + (1<<20)) >> 21; s7 += carry6; s6 -= carry6 << 21;
 2602|      1|  carry8 = (s8 + (1<<20)) >> 21; s9 += carry8; s8 -= carry8 << 21;
 2603|      1|  carry10 = (s10 + (1<<20)) >> 21; s11 += carry10; s10 -= carry10 << 21;
 2604|       |
 2605|      1|  carry1 = (s1 + (1<<20)) >> 21; s2 += carry1; s1 -= carry1 << 21;
 2606|      1|  carry3 = (s3 + (1<<20)) >> 21; s4 += carry3; s3 -= carry3 << 21;
 2607|      1|  carry5 = (s5 + (1<<20)) >> 21; s6 += carry5; s5 -= carry5 << 21;
 2608|      1|  carry7 = (s7 + (1<<20)) >> 21; s8 += carry7; s7 -= carry7 << 21;
 2609|      1|  carry9 = (s9 + (1<<20)) >> 21; s10 += carry9; s9 -= carry9 << 21;
 2610|      1|  carry11 = (s11 + (1<<20)) >> 21; s12 += carry11; s11 -= carry11 << 21;
 2611|       |
 2612|      1|  s0 += s12 * 666643;
 2613|      1|  s1 += s12 * 470296;
 2614|      1|  s2 += s12 * 654183;
 2615|      1|  s3 -= s12 * 997805;
 2616|      1|  s4 += s12 * 136657;
 2617|      1|  s5 -= s12 * 683901;
 2618|      1|  s12 = 0;
 2619|       |
 2620|      1|  carry0 = s0 >> 21; s1 += carry0; s0 -= carry0 << 21;
 2621|      1|  carry1 = s1 >> 21; s2 += carry1; s1 -= carry1 << 21;
 2622|      1|  carry2 = s2 >> 21; s3 += carry2; s2 -= carry2 << 21;
 2623|      1|  carry3 = s3 >> 21; s4 += carry3; s3 -= carry3 << 21;
 2624|      1|  carry4 = s4 >> 21; s5 += carry4; s4 -= carry4 << 21;
 2625|      1|  carry5 = s5 >> 21; s6 += carry5; s5 -= carry5 << 21;
 2626|      1|  carry6 = s6 >> 21; s7 += carry6; s6 -= carry6 << 21;
 2627|      1|  carry7 = s7 >> 21; s8 += carry7; s7 -= carry7 << 21;
 2628|      1|  carry8 = s8 >> 21; s9 += carry8; s8 -= carry8 << 21;
 2629|      1|  carry9 = s9 >> 21; s10 += carry9; s9 -= carry9 << 21;
 2630|      1|  carry10 = s10 >> 21; s11 += carry10; s10 -= carry10 << 21;
 2631|      1|  carry11 = s11 >> 21; s12 += carry11; s11 -= carry11 << 21;
 2632|       |
 2633|      1|  s0 += s12 * 666643;
 2634|      1|  s1 += s12 * 470296;
 2635|      1|  s2 += s12 * 654183;
 2636|      1|  s3 -= s12 * 997805;
 2637|      1|  s4 += s12 * 136657;
 2638|      1|  s5 -= s12 * 683901;
 2639|       |
 2640|      1|  carry0 = s0 >> 21; s1 += carry0; s0 -= carry0 << 21;
 2641|      1|  carry1 = s1 >> 21; s2 += carry1; s1 -= carry1 << 21;
 2642|      1|  carry2 = s2 >> 21; s3 += carry2; s2 -= carry2 << 21;
 2643|      1|  carry3 = s3 >> 21; s4 += carry3; s3 -= carry3 << 21;
 2644|      1|  carry4 = s4 >> 21; s5 += carry4; s4 -= carry4 << 21;
 2645|      1|  carry5 = s5 >> 21; s6 += carry5; s5 -= carry5 << 21;
 2646|      1|  carry6 = s6 >> 21; s7 += carry6; s6 -= carry6 << 21;
 2647|      1|  carry7 = s7 >> 21; s8 += carry7; s7 -= carry7 << 21;
 2648|      1|  carry8 = s8 >> 21; s9 += carry8; s8 -= carry8 << 21;
 2649|      1|  carry9 = s9 >> 21; s10 += carry9; s9 -= carry9 << 21;
 2650|      1|  carry10 = s10 >> 21; s11 += carry10; s10 -= carry10 << 21;
 2651|       |
 2652|      1|  s[0] = s0 >> 0;
 2653|      1|  s[1] = s0 >> 8;
 2654|      1|  s[2] = (s0 >> 16) | (s1 << 5);
 2655|      1|  s[3] = s1 >> 3;
 2656|      1|  s[4] = s1 >> 11;
 2657|      1|  s[5] = (s1 >> 19) | (s2 << 2);
 2658|      1|  s[6] = s2 >> 6;
 2659|      1|  s[7] = (s2 >> 14) | (s3 << 7);
 2660|      1|  s[8] = s3 >> 1;
 2661|      1|  s[9] = s3 >> 9;
 2662|      1|  s[10] = (s3 >> 17) | (s4 << 4);
 2663|      1|  s[11] = s4 >> 4;
 2664|      1|  s[12] = s4 >> 12;
 2665|      1|  s[13] = (s4 >> 20) | (s5 << 1);
 2666|      1|  s[14] = s5 >> 7;
 2667|      1|  s[15] = (s5 >> 15) | (s6 << 6);
 2668|      1|  s[16] = s6 >> 2;
 2669|      1|  s[17] = s6 >> 10;
 2670|      1|  s[18] = (s6 >> 18) | (s7 << 3);
 2671|      1|  s[19] = s7 >> 5;
 2672|      1|  s[20] = s7 >> 13;
 2673|      1|  s[21] = s8 >> 0;
 2674|      1|  s[22] = s8 >> 8;
 2675|      1|  s[23] = (s8 >> 16) | (s9 << 5);
 2676|      1|  s[24] = s9 >> 3;
 2677|      1|  s[25] = s9 >> 11;
 2678|      1|  s[26] = (s9 >> 19) | (s10 << 2);
 2679|      1|  s[27] = s10 >> 6;
 2680|      1|  s[28] = (s10 >> 14) | (s11 << 7);
 2681|      1|  s[29] = s11 >> 1;
 2682|      1|  s[30] = s11 >> 9;
 2683|      1|  s[31] = s11 >> 17;
 2684|      1|}
sc_mulsub:
 2836|  5.59k|void sc_mulsub(unsigned char *s, const unsigned char *a, const unsigned char *b, const unsigned char *c) {
 2837|  5.59k|  int64_t a0 = 2097151 & load_3(a);
 2838|  5.59k|  int64_t a1 = 2097151 & (load_4(a + 2) >> 5);
 2839|  5.59k|  int64_t a2 = 2097151 & (load_3(a + 5) >> 2);
 2840|  5.59k|  int64_t a3 = 2097151 & (load_4(a + 7) >> 7);
 2841|  5.59k|  int64_t a4 = 2097151 & (load_4(a + 10) >> 4);
 2842|  5.59k|  int64_t a5 = 2097151 & (load_3(a + 13) >> 1);
 2843|  5.59k|  int64_t a6 = 2097151 & (load_4(a + 15) >> 6);
 2844|  5.59k|  int64_t a7 = 2097151 & (load_3(a + 18) >> 3);
 2845|  5.59k|  int64_t a8 = 2097151 & load_3(a + 21);
 2846|  5.59k|  int64_t a9 = 2097151 & (load_4(a + 23) >> 5);
 2847|  5.59k|  int64_t a10 = 2097151 & (load_3(a + 26) >> 2);
 2848|  5.59k|  int64_t a11 = (load_4(a + 28) >> 7);
 2849|  5.59k|  int64_t b0 = 2097151 & load_3(b);
 2850|  5.59k|  int64_t b1 = 2097151 & (load_4(b + 2) >> 5);
 2851|  5.59k|  int64_t b2 = 2097151 & (load_3(b + 5) >> 2);
 2852|  5.59k|  int64_t b3 = 2097151 & (load_4(b + 7) >> 7);
 2853|  5.59k|  int64_t b4 = 2097151 & (load_4(b + 10) >> 4);
 2854|  5.59k|  int64_t b5 = 2097151 & (load_3(b + 13) >> 1);
 2855|  5.59k|  int64_t b6 = 2097151 & (load_4(b + 15) >> 6);
 2856|  5.59k|  int64_t b7 = 2097151 & (load_3(b + 18) >> 3);
 2857|  5.59k|  int64_t b8 = 2097151 & load_3(b + 21);
 2858|  5.59k|  int64_t b9 = 2097151 & (load_4(b + 23) >> 5);
 2859|  5.59k|  int64_t b10 = 2097151 & (load_3(b + 26) >> 2);
 2860|  5.59k|  int64_t b11 = (load_4(b + 28) >> 7);
 2861|  5.59k|  int64_t c0 = 2097151 & load_3(c);
 2862|  5.59k|  int64_t c1 = 2097151 & (load_4(c + 2) >> 5);
 2863|  5.59k|  int64_t c2 = 2097151 & (load_3(c + 5) >> 2);
 2864|  5.59k|  int64_t c3 = 2097151 & (load_4(c + 7) >> 7);
 2865|  5.59k|  int64_t c4 = 2097151 & (load_4(c + 10) >> 4);
 2866|  5.59k|  int64_t c5 = 2097151 & (load_3(c + 13) >> 1);
 2867|  5.59k|  int64_t c6 = 2097151 & (load_4(c + 15) >> 6);
 2868|  5.59k|  int64_t c7 = 2097151 & (load_3(c + 18) >> 3);
 2869|  5.59k|  int64_t c8 = 2097151 & load_3(c + 21);
 2870|  5.59k|  int64_t c9 = 2097151 & (load_4(c + 23) >> 5);
 2871|  5.59k|  int64_t c10 = 2097151 & (load_3(c + 26) >> 2);
 2872|  5.59k|  int64_t c11 = (load_4(c + 28) >> 7);
 2873|  5.59k|  int64_t s0;
 2874|  5.59k|  int64_t s1;
 2875|  5.59k|  int64_t s2;
 2876|  5.59k|  int64_t s3;
 2877|  5.59k|  int64_t s4;
 2878|  5.59k|  int64_t s5;
 2879|  5.59k|  int64_t s6;
 2880|  5.59k|  int64_t s7;
 2881|  5.59k|  int64_t s8;
 2882|  5.59k|  int64_t s9;
 2883|  5.59k|  int64_t s10;
 2884|  5.59k|  int64_t s11;
 2885|  5.59k|  int64_t s12;
 2886|  5.59k|  int64_t s13;
 2887|  5.59k|  int64_t s14;
 2888|  5.59k|  int64_t s15;
 2889|  5.59k|  int64_t s16;
 2890|  5.59k|  int64_t s17;
 2891|  5.59k|  int64_t s18;
 2892|  5.59k|  int64_t s19;
 2893|  5.59k|  int64_t s20;
 2894|  5.59k|  int64_t s21;
 2895|  5.59k|  int64_t s22;
 2896|  5.59k|  int64_t s23;
 2897|  5.59k|  int64_t carry0;
 2898|  5.59k|  int64_t carry1;
 2899|  5.59k|  int64_t carry2;
 2900|  5.59k|  int64_t carry3;
 2901|  5.59k|  int64_t carry4;
 2902|  5.59k|  int64_t carry5;
 2903|  5.59k|  int64_t carry6;
 2904|  5.59k|  int64_t carry7;
 2905|  5.59k|  int64_t carry8;
 2906|  5.59k|  int64_t carry9;
 2907|  5.59k|  int64_t carry10;
 2908|  5.59k|  int64_t carry11;
 2909|  5.59k|  int64_t carry12;
 2910|  5.59k|  int64_t carry13;
 2911|  5.59k|  int64_t carry14;
 2912|  5.59k|  int64_t carry15;
 2913|  5.59k|  int64_t carry16;
 2914|  5.59k|  int64_t carry17;
 2915|  5.59k|  int64_t carry18;
 2916|  5.59k|  int64_t carry19;
 2917|  5.59k|  int64_t carry20;
 2918|  5.59k|  int64_t carry21;
 2919|  5.59k|  int64_t carry22;
 2920|       |
 2921|  5.59k|  s0 = c0 - a0*b0;
 2922|  5.59k|  s1 = c1 - (a0*b1 + a1*b0);
 2923|  5.59k|  s2 = c2 - (a0*b2 + a1*b1 + a2*b0);
 2924|  5.59k|  s3 = c3 - (a0*b3 + a1*b2 + a2*b1 + a3*b0);
 2925|  5.59k|  s4 = c4 - (a0*b4 + a1*b3 + a2*b2 + a3*b1 + a4*b0);
 2926|  5.59k|  s5 = c5 - (a0*b5 + a1*b4 + a2*b3 + a3*b2 + a4*b1 + a5*b0);
 2927|  5.59k|  s6 = c6 - (a0*b6 + a1*b5 + a2*b4 + a3*b3 + a4*b2 + a5*b1 + a6*b0);
 2928|  5.59k|  s7 = c7 - (a0*b7 + a1*b6 + a2*b5 + a3*b4 + a4*b3 + a5*b2 + a6*b1 + a7*b0);
 2929|  5.59k|  s8 = c8 - (a0*b8 + a1*b7 + a2*b6 + a3*b5 + a4*b4 + a5*b3 + a6*b2 + a7*b1 + a8*b0);
 2930|  5.59k|  s9 = c9 - (a0*b9 + a1*b8 + a2*b7 + a3*b6 + a4*b5 + a5*b4 + a6*b3 + a7*b2 + a8*b1 + a9*b0);
 2931|  5.59k|  s10 = c10 - (a0*b10 + a1*b9 + a2*b8 + a3*b7 + a4*b6 + a5*b5 + a6*b4 + a7*b3 + a8*b2 + a9*b1 + a10*b0);
 2932|  5.59k|  s11 = c11 - (a0*b11 + a1*b10 + a2*b9 + a3*b8 + a4*b7 + a5*b6 + a6*b5 + a7*b4 + a8*b3 + a9*b2 + a10*b1 + a11*b0);
 2933|  5.59k|  s12 = -(a1*b11 + a2*b10 + a3*b9 + a4*b8 + a5*b7 + a6*b6 + a7*b5 + a8*b4 + a9*b3 + a10*b2 + a11*b1);
 2934|  5.59k|  s13 = -(a2*b11 + a3*b10 + a4*b9 + a5*b8 + a6*b7 + a7*b6 + a8*b5 + a9*b4 + a10*b3 + a11*b2);
 2935|  5.59k|  s14 = -(a3*b11 + a4*b10 + a5*b9 + a6*b8 + a7*b7 + a8*b6 + a9*b5 + a10*b4 + a11*b3);
 2936|  5.59k|  s15 = -(a4*b11 + a5*b10 + a6*b9 + a7*b8 + a8*b7 + a9*b6 + a10*b5 + a11*b4);
 2937|  5.59k|  s16 = -(a5*b11 + a6*b10 + a7*b9 + a8*b8 + a9*b7 + a10*b6 + a11*b5);
 2938|  5.59k|  s17 = -(a6*b11 + a7*b10 + a8*b9 + a9*b8 + a10*b7 + a11*b6);
 2939|  5.59k|  s18 = -(a7*b11 + a8*b10 + a9*b9 + a10*b8 + a11*b7);
 2940|  5.59k|  s19 = -(a8*b11 + a9*b10 + a10*b9 + a11*b8);
 2941|  5.59k|  s20 = -(a9*b11 + a10*b10 + a11*b9);
 2942|  5.59k|  s21 = -(a10*b11 + a11*b10);
 2943|  5.59k|  s22 = -a11*b11;
 2944|  5.59k|  s23 = 0;
 2945|       |
 2946|  5.59k|  carry0 = (s0 + (1<<20)) >> 21; s1 += carry0; s0 -= carry0 << 21;
 2947|  5.59k|  carry2 = (s2 + (1<<20)) >> 21; s3 += carry2; s2 -= carry2 << 21;
 2948|  5.59k|  carry4 = (s4 + (1<<20)) >> 21; s5 += carry4; s4 -= carry4 << 21;
 2949|  5.59k|  carry6 = (s6 + (1<<20)) >> 21; s7 += carry6; s6 -= carry6 << 21;
 2950|  5.59k|  carry8 = (s8 + (1<<20)) >> 21; s9 += carry8; s8 -= carry8 << 21;
 2951|  5.59k|  carry10 = (s10 + (1<<20)) >> 21; s11 += carry10; s10 -= carry10 << 21;
 2952|  5.59k|  carry12 = (s12 + (1<<20)) >> 21; s13 += carry12; s12 -= carry12 << 21;
 2953|  5.59k|  carry14 = (s14 + (1<<20)) >> 21; s15 += carry14; s14 -= carry14 << 21;
 2954|  5.59k|  carry16 = (s16 + (1<<20)) >> 21; s17 += carry16; s16 -= carry16 << 21;
 2955|  5.59k|  carry18 = (s18 + (1<<20)) >> 21; s19 += carry18; s18 -= carry18 << 21;
 2956|  5.59k|  carry20 = (s20 + (1<<20)) >> 21; s21 += carry20; s20 -= carry20 << 21;
 2957|  5.59k|  carry22 = (s22 + (1<<20)) >> 21; s23 += carry22; s22 -= carry22 << 21;
 2958|       |
 2959|  5.59k|  carry1 = (s1 + (1<<20)) >> 21; s2 += carry1; s1 -= carry1 << 21;
 2960|  5.59k|  carry3 = (s3 + (1<<20)) >> 21; s4 += carry3; s3 -= carry3 << 21;
 2961|  5.59k|  carry5 = (s5 + (1<<20)) >> 21; s6 += carry5; s5 -= carry5 << 21;
 2962|  5.59k|  carry7 = (s7 + (1<<20)) >> 21; s8 += carry7; s7 -= carry7 << 21;
 2963|  5.59k|  carry9 = (s9 + (1<<20)) >> 21; s10 += carry9; s9 -= carry9 << 21;
 2964|  5.59k|  carry11 = (s11 + (1<<20)) >> 21; s12 += carry11; s11 -= carry11 << 21;
 2965|  5.59k|  carry13 = (s13 + (1<<20)) >> 21; s14 += carry13; s13 -= carry13 << 21;
 2966|  5.59k|  carry15 = (s15 + (1<<20)) >> 21; s16 += carry15; s15 -= carry15 << 21;
 2967|  5.59k|  carry17 = (s17 + (1<<20)) >> 21; s18 += carry17; s17 -= carry17 << 21;
 2968|  5.59k|  carry19 = (s19 + (1<<20)) >> 21; s20 += carry19; s19 -= carry19 << 21;
 2969|  5.59k|  carry21 = (s21 + (1<<20)) >> 21; s22 += carry21; s21 -= carry21 << 21;
 2970|       |
 2971|  5.59k|  s11 += s23 * 666643;
 2972|  5.59k|  s12 += s23 * 470296;
 2973|  5.59k|  s13 += s23 * 654183;
 2974|  5.59k|  s14 -= s23 * 997805;
 2975|  5.59k|  s15 += s23 * 136657;
 2976|  5.59k|  s16 -= s23 * 683901;
 2977|       |
 2978|  5.59k|  s10 += s22 * 666643;
 2979|  5.59k|  s11 += s22 * 470296;
 2980|  5.59k|  s12 += s22 * 654183;
 2981|  5.59k|  s13 -= s22 * 997805;
 2982|  5.59k|  s14 += s22 * 136657;
 2983|  5.59k|  s15 -= s22 * 683901;
 2984|       |
 2985|  5.59k|  s9 += s21 * 666643;
 2986|  5.59k|  s10 += s21 * 470296;
 2987|  5.59k|  s11 += s21 * 654183;
 2988|  5.59k|  s12 -= s21 * 997805;
 2989|  5.59k|  s13 += s21 * 136657;
 2990|  5.59k|  s14 -= s21 * 683901;
 2991|       |
 2992|  5.59k|  s8 += s20 * 666643;
 2993|  5.59k|  s9 += s20 * 470296;
 2994|  5.59k|  s10 += s20 * 654183;
 2995|  5.59k|  s11 -= s20 * 997805;
 2996|  5.59k|  s12 += s20 * 136657;
 2997|  5.59k|  s13 -= s20 * 683901;
 2998|       |
 2999|  5.59k|  s7 += s19 * 666643;
 3000|  5.59k|  s8 += s19 * 470296;
 3001|  5.59k|  s9 += s19 * 654183;
 3002|  5.59k|  s10 -= s19 * 997805;
 3003|  5.59k|  s11 += s19 * 136657;
 3004|  5.59k|  s12 -= s19 * 683901;
 3005|       |
 3006|  5.59k|  s6 += s18 * 666643;
 3007|  5.59k|  s7 += s18 * 470296;
 3008|  5.59k|  s8 += s18 * 654183;
 3009|  5.59k|  s9 -= s18 * 997805;
 3010|  5.59k|  s10 += s18 * 136657;
 3011|  5.59k|  s11 -= s18 * 683901;
 3012|       |
 3013|  5.59k|  carry6 = (s6 + (1<<20)) >> 21; s7 += carry6; s6 -= carry6 << 21;
 3014|  5.59k|  carry8 = (s8 + (1<<20)) >> 21; s9 += carry8; s8 -= carry8 << 21;
 3015|  5.59k|  carry10 = (s10 + (1<<20)) >> 21; s11 += carry10; s10 -= carry10 << 21;
 3016|  5.59k|  carry12 = (s12 + (1<<20)) >> 21; s13 += carry12; s12 -= carry12 << 21;
 3017|  5.59k|  carry14 = (s14 + (1<<20)) >> 21; s15 += carry14; s14 -= carry14 << 21;
 3018|  5.59k|  carry16 = (s16 + (1<<20)) >> 21; s17 += carry16; s16 -= carry16 << 21;
 3019|       |
 3020|  5.59k|  carry7 = (s7 + (1<<20)) >> 21; s8 += carry7; s7 -= carry7 << 21;
 3021|  5.59k|  carry9 = (s9 + (1<<20)) >> 21; s10 += carry9; s9 -= carry9 << 21;
 3022|  5.59k|  carry11 = (s11 + (1<<20)) >> 21; s12 += carry11; s11 -= carry11 << 21;
 3023|  5.59k|  carry13 = (s13 + (1<<20)) >> 21; s14 += carry13; s13 -= carry13 << 21;
 3024|  5.59k|  carry15 = (s15 + (1<<20)) >> 21; s16 += carry15; s15 -= carry15 << 21;
 3025|       |
 3026|  5.59k|  s5 += s17 * 666643;
 3027|  5.59k|  s6 += s17 * 470296;
 3028|  5.59k|  s7 += s17 * 654183;
 3029|  5.59k|  s8 -= s17 * 997805;
 3030|  5.59k|  s9 += s17 * 136657;
 3031|  5.59k|  s10 -= s17 * 683901;
 3032|       |
 3033|  5.59k|  s4 += s16 * 666643;
 3034|  5.59k|  s5 += s16 * 470296;
 3035|  5.59k|  s6 += s16 * 654183;
 3036|  5.59k|  s7 -= s16 * 997805;
 3037|  5.59k|  s8 += s16 * 136657;
 3038|  5.59k|  s9 -= s16 * 683901;
 3039|       |
 3040|  5.59k|  s3 += s15 * 666643;
 3041|  5.59k|  s4 += s15 * 470296;
 3042|  5.59k|  s5 += s15 * 654183;
 3043|  5.59k|  s6 -= s15 * 997805;
 3044|  5.59k|  s7 += s15 * 136657;
 3045|  5.59k|  s8 -= s15 * 683901;
 3046|       |
 3047|  5.59k|  s2 += s14 * 666643;
 3048|  5.59k|  s3 += s14 * 470296;
 3049|  5.59k|  s4 += s14 * 654183;
 3050|  5.59k|  s5 -= s14 * 997805;
 3051|  5.59k|  s6 += s14 * 136657;
 3052|  5.59k|  s7 -= s14 * 683901;
 3053|       |
 3054|  5.59k|  s1 += s13 * 666643;
 3055|  5.59k|  s2 += s13 * 470296;
 3056|  5.59k|  s3 += s13 * 654183;
 3057|  5.59k|  s4 -= s13 * 997805;
 3058|  5.59k|  s5 += s13 * 136657;
 3059|  5.59k|  s6 -= s13 * 683901;
 3060|       |
 3061|  5.59k|  s0 += s12 * 666643;
 3062|  5.59k|  s1 += s12 * 470296;
 3063|  5.59k|  s2 += s12 * 654183;
 3064|  5.59k|  s3 -= s12 * 997805;
 3065|  5.59k|  s4 += s12 * 136657;
 3066|  5.59k|  s5 -= s12 * 683901;
 3067|  5.59k|  s12 = 0;
 3068|       |
 3069|  5.59k|  carry0 = (s0 + (1<<20)) >> 21; s1 += carry0; s0 -= carry0 << 21;
 3070|  5.59k|  carry2 = (s2 + (1<<20)) >> 21; s3 += carry2; s2 -= carry2 << 21;
 3071|  5.59k|  carry4 = (s4 + (1<<20)) >> 21; s5 += carry4; s4 -= carry4 << 21;
 3072|  5.59k|  carry6 = (s6 + (1<<20)) >> 21; s7 += carry6; s6 -= carry6 << 21;
 3073|  5.59k|  carry8 = (s8 + (1<<20)) >> 21; s9 += carry8; s8 -= carry8 << 21;
 3074|  5.59k|  carry10 = (s10 + (1<<20)) >> 21; s11 += carry10; s10 -= carry10 << 21;
 3075|       |
 3076|  5.59k|  carry1 = (s1 + (1<<20)) >> 21; s2 += carry1; s1 -= carry1 << 21;
 3077|  5.59k|  carry3 = (s3 + (1<<20)) >> 21; s4 += carry3; s3 -= carry3 << 21;
 3078|  5.59k|  carry5 = (s5 + (1<<20)) >> 21; s6 += carry5; s5 -= carry5 << 21;
 3079|  5.59k|  carry7 = (s7 + (1<<20)) >> 21; s8 += carry7; s7 -= carry7 << 21;
 3080|  5.59k|  carry9 = (s9 + (1<<20)) >> 21; s10 += carry9; s9 -= carry9 << 21;
 3081|  5.59k|  carry11 = (s11 + (1<<20)) >> 21; s12 += carry11; s11 -= carry11 << 21;
 3082|       |
 3083|  5.59k|  s0 += s12 * 666643;
 3084|  5.59k|  s1 += s12 * 470296;
 3085|  5.59k|  s2 += s12 * 654183;
 3086|  5.59k|  s3 -= s12 * 997805;
 3087|  5.59k|  s4 += s12 * 136657;
 3088|  5.59k|  s5 -= s12 * 683901;
 3089|  5.59k|  s12 = 0;
 3090|       |
 3091|  5.59k|  carry0 = s0 >> 21; s1 += carry0; s0 -= carry0 << 21;
 3092|  5.59k|  carry1 = s1 >> 21; s2 += carry1; s1 -= carry1 << 21;
 3093|  5.59k|  carry2 = s2 >> 21; s3 += carry2; s2 -= carry2 << 21;
 3094|  5.59k|  carry3 = s3 >> 21; s4 += carry3; s3 -= carry3 << 21;
 3095|  5.59k|  carry4 = s4 >> 21; s5 += carry4; s4 -= carry4 << 21;
 3096|  5.59k|  carry5 = s5 >> 21; s6 += carry5; s5 -= carry5 << 21;
 3097|  5.59k|  carry6 = s6 >> 21; s7 += carry6; s6 -= carry6 << 21;
 3098|  5.59k|  carry7 = s7 >> 21; s8 += carry7; s7 -= carry7 << 21;
 3099|  5.59k|  carry8 = s8 >> 21; s9 += carry8; s8 -= carry8 << 21;
 3100|  5.59k|  carry9 = s9 >> 21; s10 += carry9; s9 -= carry9 << 21;
 3101|  5.59k|  carry10 = s10 >> 21; s11 += carry10; s10 -= carry10 << 21;
 3102|  5.59k|  carry11 = s11 >> 21; s12 += carry11; s11 -= carry11 << 21;
 3103|       |
 3104|  5.59k|  s0 += s12 * 666643;
 3105|  5.59k|  s1 += s12 * 470296;
 3106|  5.59k|  s2 += s12 * 654183;
 3107|  5.59k|  s3 -= s12 * 997805;
 3108|  5.59k|  s4 += s12 * 136657;
 3109|  5.59k|  s5 -= s12 * 683901;
 3110|       |
 3111|  5.59k|  carry0 = s0 >> 21; s1 += carry0; s0 -= carry0 << 21;
 3112|  5.59k|  carry1 = s1 >> 21; s2 += carry1; s1 -= carry1 << 21;
 3113|  5.59k|  carry2 = s2 >> 21; s3 += carry2; s2 -= carry2 << 21;
 3114|  5.59k|  carry3 = s3 >> 21; s4 += carry3; s3 -= carry3 << 21;
 3115|  5.59k|  carry4 = s4 >> 21; s5 += carry4; s4 -= carry4 << 21;
 3116|  5.59k|  carry5 = s5 >> 21; s6 += carry5; s5 -= carry5 << 21;
 3117|  5.59k|  carry6 = s6 >> 21; s7 += carry6; s6 -= carry6 << 21;
 3118|  5.59k|  carry7 = s7 >> 21; s8 += carry7; s7 -= carry7 << 21;
 3119|  5.59k|  carry8 = s8 >> 21; s9 += carry8; s8 -= carry8 << 21;
 3120|  5.59k|  carry9 = s9 >> 21; s10 += carry9; s9 -= carry9 << 21;
 3121|  5.59k|  carry10 = s10 >> 21; s11 += carry10; s10 -= carry10 << 21;
 3122|       |
 3123|  5.59k|  s[0] = s0 >> 0;
 3124|  5.59k|  s[1] = s0 >> 8;
 3125|  5.59k|  s[2] = (s0 >> 16) | (s1 << 5);
 3126|  5.59k|  s[3] = s1 >> 3;
 3127|  5.59k|  s[4] = s1 >> 11;
 3128|  5.59k|  s[5] = (s1 >> 19) | (s2 << 2);
 3129|  5.59k|  s[6] = s2 >> 6;
 3130|  5.59k|  s[7] = (s2 >> 14) | (s3 << 7);
 3131|  5.59k|  s[8] = s3 >> 1;
 3132|  5.59k|  s[9] = s3 >> 9;
 3133|  5.59k|  s[10] = (s3 >> 17) | (s4 << 4);
 3134|  5.59k|  s[11] = s4 >> 4;
 3135|  5.59k|  s[12] = s4 >> 12;
 3136|  5.59k|  s[13] = (s4 >> 20) | (s5 << 1);
 3137|  5.59k|  s[14] = s5 >> 7;
 3138|  5.59k|  s[15] = (s5 >> 15) | (s6 << 6);
 3139|  5.59k|  s[16] = s6 >> 2;
 3140|  5.59k|  s[17] = s6 >> 10;
 3141|  5.59k|  s[18] = (s6 >> 18) | (s7 << 3);
 3142|  5.59k|  s[19] = s7 >> 5;
 3143|  5.59k|  s[20] = s7 >> 13;
 3144|  5.59k|  s[21] = s8 >> 0;
 3145|  5.59k|  s[22] = s8 >> 8;
 3146|  5.59k|  s[23] = (s8 >> 16) | (s9 << 5);
 3147|  5.59k|  s[24] = s9 >> 3;
 3148|  5.59k|  s[25] = s9 >> 11;
 3149|  5.59k|  s[26] = (s9 >> 19) | (s10 << 2);
 3150|  5.59k|  s[27] = s10 >> 6;
 3151|  5.59k|  s[28] = (s10 >> 14) | (s11 << 7);
 3152|  5.59k|  s[29] = s11 >> 1;
 3153|  5.59k|  s[30] = s11 >> 9;
 3154|  5.59k|  s[31] = s11 >> 17;
 3155|  5.59k|}
sc_mul:
 3167|    124|void sc_mul(unsigned char *s, const unsigned char *a, const unsigned char *b) {
 3168|    124|  int64_t a0 = 2097151 & load_3(a);
 3169|    124|  int64_t a1 = 2097151 & (load_4(a + 2) >> 5);
 3170|    124|  int64_t a2 = 2097151 & (load_3(a + 5) >> 2);
 3171|    124|  int64_t a3 = 2097151 & (load_4(a + 7) >> 7);
 3172|    124|  int64_t a4 = 2097151 & (load_4(a + 10) >> 4);
 3173|    124|  int64_t a5 = 2097151 & (load_3(a + 13) >> 1);
 3174|    124|  int64_t a6 = 2097151 & (load_4(a + 15) >> 6);
 3175|    124|  int64_t a7 = 2097151 & (load_3(a + 18) >> 3);
 3176|    124|  int64_t a8 = 2097151 & load_3(a + 21);
 3177|    124|  int64_t a9 = 2097151 & (load_4(a + 23) >> 5);
 3178|    124|  int64_t a10 = 2097151 & (load_3(a + 26) >> 2);
 3179|    124|  int64_t a11 = (load_4(a + 28) >> 7);
 3180|    124|  int64_t b0 = 2097151 & load_3(b);
 3181|    124|  int64_t b1 = 2097151 & (load_4(b + 2) >> 5);
 3182|    124|  int64_t b2 = 2097151 & (load_3(b + 5) >> 2);
 3183|    124|  int64_t b3 = 2097151 & (load_4(b + 7) >> 7);
 3184|    124|  int64_t b4 = 2097151 & (load_4(b + 10) >> 4);
 3185|    124|  int64_t b5 = 2097151 & (load_3(b + 13) >> 1);
 3186|    124|  int64_t b6 = 2097151 & (load_4(b + 15) >> 6);
 3187|    124|  int64_t b7 = 2097151 & (load_3(b + 18) >> 3);
 3188|    124|  int64_t b8 = 2097151 & load_3(b + 21);
 3189|    124|  int64_t b9 = 2097151 & (load_4(b + 23) >> 5);
 3190|    124|  int64_t b10 = 2097151 & (load_3(b + 26) >> 2);
 3191|    124|  int64_t b11 = (load_4(b + 28) >> 7);
 3192|    124|  int64_t s0;
 3193|    124|  int64_t s1;
 3194|    124|  int64_t s2;
 3195|    124|  int64_t s3;
 3196|    124|  int64_t s4;
 3197|    124|  int64_t s5;
 3198|    124|  int64_t s6;
 3199|    124|  int64_t s7;
 3200|    124|  int64_t s8;
 3201|    124|  int64_t s9;
 3202|    124|  int64_t s10;
 3203|    124|  int64_t s11;
 3204|    124|  int64_t s12;
 3205|    124|  int64_t s13;
 3206|    124|  int64_t s14;
 3207|    124|  int64_t s15;
 3208|    124|  int64_t s16;
 3209|    124|  int64_t s17;
 3210|    124|  int64_t s18;
 3211|    124|  int64_t s19;
 3212|    124|  int64_t s20;
 3213|    124|  int64_t s21;
 3214|    124|  int64_t s22;
 3215|    124|  int64_t s23;
 3216|    124|  int64_t carry0;
 3217|    124|  int64_t carry1;
 3218|    124|  int64_t carry2;
 3219|    124|  int64_t carry3;
 3220|    124|  int64_t carry4;
 3221|    124|  int64_t carry5;
 3222|    124|  int64_t carry6;
 3223|    124|  int64_t carry7;
 3224|    124|  int64_t carry8;
 3225|    124|  int64_t carry9;
 3226|    124|  int64_t carry10;
 3227|    124|  int64_t carry11;
 3228|    124|  int64_t carry12;
 3229|    124|  int64_t carry13;
 3230|    124|  int64_t carry14;
 3231|    124|  int64_t carry15;
 3232|    124|  int64_t carry16;
 3233|    124|  int64_t carry17;
 3234|    124|  int64_t carry18;
 3235|    124|  int64_t carry19;
 3236|    124|  int64_t carry20;
 3237|    124|  int64_t carry21;
 3238|    124|  int64_t carry22;
 3239|       |
 3240|    124|  s0 = a0*b0;
 3241|    124|  s1 = (a0*b1 + a1*b0);
 3242|    124|  s2 = (a0*b2 + a1*b1 + a2*b0);
 3243|    124|  s3 = (a0*b3 + a1*b2 + a2*b1 + a3*b0);
 3244|    124|  s4 = (a0*b4 + a1*b3 + a2*b2 + a3*b1 + a4*b0);
 3245|    124|  s5 = (a0*b5 + a1*b4 + a2*b3 + a3*b2 + a4*b1 + a5*b0);
 3246|    124|  s6 = (a0*b6 + a1*b5 + a2*b4 + a3*b3 + a4*b2 + a5*b1 + a6*b0);
 3247|    124|  s7 = (a0*b7 + a1*b6 + a2*b5 + a3*b4 + a4*b3 + a5*b2 + a6*b1 + a7*b0);
 3248|    124|  s8 = (a0*b8 + a1*b7 + a2*b6 + a3*b5 + a4*b4 + a5*b3 + a6*b2 + a7*b1 + a8*b0);
 3249|    124|  s9 = (a0*b9 + a1*b8 + a2*b7 + a3*b6 + a4*b5 + a5*b4 + a6*b3 + a7*b2 + a8*b1 + a9*b0);
 3250|    124|  s10 = (a0*b10 + a1*b9 + a2*b8 + a3*b7 + a4*b6 + a5*b5 + a6*b4 + a7*b3 + a8*b2 + a9*b1 + a10*b0);
 3251|    124|  s11 = (a0*b11 + a1*b10 + a2*b9 + a3*b8 + a4*b7 + a5*b6 + a6*b5 + a7*b4 + a8*b3 + a9*b2 + a10*b1 + a11*b0);
 3252|    124|  s12 = (a1*b11 + a2*b10 + a3*b9 + a4*b8 + a5*b7 + a6*b6 + a7*b5 + a8*b4 + a9*b3 + a10*b2 + a11*b1);
 3253|    124|  s13 = (a2*b11 + a3*b10 + a4*b9 + a5*b8 + a6*b7 + a7*b6 + a8*b5 + a9*b4 + a10*b3 + a11*b2);
 3254|    124|  s14 = (a3*b11 + a4*b10 + a5*b9 + a6*b8 + a7*b7 + a8*b6 + a9*b5 + a10*b4 + a11*b3);
 3255|    124|  s15 = (a4*b11 + a5*b10 + a6*b9 + a7*b8 + a8*b7 + a9*b6 + a10*b5 + a11*b4);
 3256|    124|  s16 = (a5*b11 + a6*b10 + a7*b9 + a8*b8 + a9*b7 + a10*b6 + a11*b5);
 3257|    124|  s17 = (a6*b11 + a7*b10 + a8*b9 + a9*b8 + a10*b7 + a11*b6);
 3258|    124|  s18 = (a7*b11 + a8*b10 + a9*b9 + a10*b8 + a11*b7);
 3259|    124|  s19 = (a8*b11 + a9*b10 + a10*b9 + a11*b8);
 3260|    124|  s20 = (a9*b11 + a10*b10 + a11*b9);
 3261|    124|  s21 = (a10*b11 + a11*b10);
 3262|    124|  s22 = a11*b11;
 3263|    124|  s23 = 0;
 3264|       |
 3265|    124|  carry0 = (s0 + (1<<20)) >> 21; s1 += carry0; s0 -= carry0 << 21;
 3266|    124|  carry2 = (s2 + (1<<20)) >> 21; s3 += carry2; s2 -= carry2 << 21;
 3267|    124|  carry4 = (s4 + (1<<20)) >> 21; s5 += carry4; s4 -= carry4 << 21;
 3268|    124|  carry6 = (s6 + (1<<20)) >> 21; s7 += carry6; s6 -= carry6 << 21;
 3269|    124|  carry8 = (s8 + (1<<20)) >> 21; s9 += carry8; s8 -= carry8 << 21;
 3270|    124|  carry10 = (s10 + (1<<20)) >> 21; s11 += carry10; s10 -= carry10 << 21;
 3271|    124|  carry12 = (s12 + (1<<20)) >> 21; s13 += carry12; s12 -= carry12 << 21;
 3272|    124|  carry14 = (s14 + (1<<20)) >> 21; s15 += carry14; s14 -= carry14 << 21;
 3273|    124|  carry16 = (s16 + (1<<20)) >> 21; s17 += carry16; s16 -= carry16 << 21;
 3274|    124|  carry18 = (s18 + (1<<20)) >> 21; s19 += carry18; s18 -= carry18 << 21;
 3275|    124|  carry20 = (s20 + (1<<20)) >> 21; s21 += carry20; s20 -= carry20 << 21;
 3276|    124|  carry22 = (s22 + (1<<20)) >> 21; s23 += carry22; s22 -= carry22 << 21;
 3277|       |
 3278|    124|  carry1 = (s1 + (1<<20)) >> 21; s2 += carry1; s1 -= carry1 << 21;
 3279|    124|  carry3 = (s3 + (1<<20)) >> 21; s4 += carry3; s3 -= carry3 << 21;
 3280|    124|  carry5 = (s5 + (1<<20)) >> 21; s6 += carry5; s5 -= carry5 << 21;
 3281|    124|  carry7 = (s7 + (1<<20)) >> 21; s8 += carry7; s7 -= carry7 << 21;
 3282|    124|  carry9 = (s9 + (1<<20)) >> 21; s10 += carry9; s9 -= carry9 << 21;
 3283|    124|  carry11 = (s11 + (1<<20)) >> 21; s12 += carry11; s11 -= carry11 << 21;
 3284|    124|  carry13 = (s13 + (1<<20)) >> 21; s14 += carry13; s13 -= carry13 << 21;
 3285|    124|  carry15 = (s15 + (1<<20)) >> 21; s16 += carry15; s15 -= carry15 << 21;
 3286|    124|  carry17 = (s17 + (1<<20)) >> 21; s18 += carry17; s17 -= carry17 << 21;
 3287|    124|  carry19 = (s19 + (1<<20)) >> 21; s20 += carry19; s19 -= carry19 << 21;
 3288|    124|  carry21 = (s21 + (1<<20)) >> 21; s22 += carry21; s21 -= carry21 << 21;
 3289|       |
 3290|    124|  s11 += s23 * 666643;
 3291|    124|  s12 += s23 * 470296;
 3292|    124|  s13 += s23 * 654183;
 3293|    124|  s14 -= s23 * 997805;
 3294|    124|  s15 += s23 * 136657;
 3295|    124|  s16 -= s23 * 683901;
 3296|       |
 3297|    124|  s10 += s22 * 666643;
 3298|    124|  s11 += s22 * 470296;
 3299|    124|  s12 += s22 * 654183;
 3300|    124|  s13 -= s22 * 997805;
 3301|    124|  s14 += s22 * 136657;
 3302|    124|  s15 -= s22 * 683901;
 3303|       |
 3304|    124|  s9 += s21 * 666643;
 3305|    124|  s10 += s21 * 470296;
 3306|    124|  s11 += s21 * 654183;
 3307|    124|  s12 -= s21 * 997805;
 3308|    124|  s13 += s21 * 136657;
 3309|    124|  s14 -= s21 * 683901;
 3310|       |
 3311|    124|  s8 += s20 * 666643;
 3312|    124|  s9 += s20 * 470296;
 3313|    124|  s10 += s20 * 654183;
 3314|    124|  s11 -= s20 * 997805;
 3315|    124|  s12 += s20 * 136657;
 3316|    124|  s13 -= s20 * 683901;
 3317|       |
 3318|    124|  s7 += s19 * 666643;
 3319|    124|  s8 += s19 * 470296;
 3320|    124|  s9 += s19 * 654183;
 3321|    124|  s10 -= s19 * 997805;
 3322|    124|  s11 += s19 * 136657;
 3323|    124|  s12 -= s19 * 683901;
 3324|       |
 3325|    124|  s6 += s18 * 666643;
 3326|    124|  s7 += s18 * 470296;
 3327|    124|  s8 += s18 * 654183;
 3328|    124|  s9 -= s18 * 997805;
 3329|    124|  s10 += s18 * 136657;
 3330|    124|  s11 -= s18 * 683901;
 3331|       |
 3332|    124|  carry6 = (s6 + (1<<20)) >> 21; s7 += carry6; s6 -= carry6 << 21;
 3333|    124|  carry8 = (s8 + (1<<20)) >> 21; s9 += carry8; s8 -= carry8 << 21;
 3334|    124|  carry10 = (s10 + (1<<20)) >> 21; s11 += carry10; s10 -= carry10 << 21;
 3335|    124|  carry12 = (s12 + (1<<20)) >> 21; s13 += carry12; s12 -= carry12 << 21;
 3336|    124|  carry14 = (s14 + (1<<20)) >> 21; s15 += carry14; s14 -= carry14 << 21;
 3337|    124|  carry16 = (s16 + (1<<20)) >> 21; s17 += carry16; s16 -= carry16 << 21;
 3338|       |
 3339|    124|  carry7 = (s7 + (1<<20)) >> 21; s8 += carry7; s7 -= carry7 << 21;
 3340|    124|  carry9 = (s9 + (1<<20)) >> 21; s10 += carry9; s9 -= carry9 << 21;
 3341|    124|  carry11 = (s11 + (1<<20)) >> 21; s12 += carry11; s11 -= carry11 << 21;
 3342|    124|  carry13 = (s13 + (1<<20)) >> 21; s14 += carry13; s13 -= carry13 << 21;
 3343|    124|  carry15 = (s15 + (1<<20)) >> 21; s16 += carry15; s15 -= carry15 << 21;
 3344|       |
 3345|    124|  s5 += s17 * 666643;
 3346|    124|  s6 += s17 * 470296;
 3347|    124|  s7 += s17 * 654183;
 3348|    124|  s8 -= s17 * 997805;
 3349|    124|  s9 += s17 * 136657;
 3350|    124|  s10 -= s17 * 683901;
 3351|       |
 3352|    124|  s4 += s16 * 666643;
 3353|    124|  s5 += s16 * 470296;
 3354|    124|  s6 += s16 * 654183;
 3355|    124|  s7 -= s16 * 997805;
 3356|    124|  s8 += s16 * 136657;
 3357|    124|  s9 -= s16 * 683901;
 3358|       |
 3359|    124|  s3 += s15 * 666643;
 3360|    124|  s4 += s15 * 470296;
 3361|    124|  s5 += s15 * 654183;
 3362|    124|  s6 -= s15 * 997805;
 3363|    124|  s7 += s15 * 136657;
 3364|    124|  s8 -= s15 * 683901;
 3365|       |
 3366|    124|  s2 += s14 * 666643;
 3367|    124|  s3 += s14 * 470296;
 3368|    124|  s4 += s14 * 654183;
 3369|    124|  s5 -= s14 * 997805;
 3370|    124|  s6 += s14 * 136657;
 3371|    124|  s7 -= s14 * 683901;
 3372|       |
 3373|    124|  s1 += s13 * 666643;
 3374|    124|  s2 += s13 * 470296;
 3375|    124|  s3 += s13 * 654183;
 3376|    124|  s4 -= s13 * 997805;
 3377|    124|  s5 += s13 * 136657;
 3378|    124|  s6 -= s13 * 683901;
 3379|       |
 3380|    124|  s0 += s12 * 666643;
 3381|    124|  s1 += s12 * 470296;
 3382|    124|  s2 += s12 * 654183;
 3383|    124|  s3 -= s12 * 997805;
 3384|    124|  s4 += s12 * 136657;
 3385|    124|  s5 -= s12 * 683901;
 3386|    124|  s12 = 0;
 3387|       |
 3388|    124|  carry0 = (s0 + (1<<20)) >> 21; s1 += carry0; s0 -= carry0 << 21;
 3389|    124|  carry2 = (s2 + (1<<20)) >> 21; s3 += carry2; s2 -= carry2 << 21;
 3390|    124|  carry4 = (s4 + (1<<20)) >> 21; s5 += carry4; s4 -= carry4 << 21;
 3391|    124|  carry6 = (s6 + (1<<20)) >> 21; s7 += carry6; s6 -= carry6 << 21;
 3392|    124|  carry8 = (s8 + (1<<20)) >> 21; s9 += carry8; s8 -= carry8 << 21;
 3393|    124|  carry10 = (s10 + (1<<20)) >> 21; s11 += carry10; s10 -= carry10 << 21;
 3394|       |
 3395|    124|  carry1 = (s1 + (1<<20)) >> 21; s2 += carry1; s1 -= carry1 << 21;
 3396|    124|  carry3 = (s3 + (1<<20)) >> 21; s4 += carry3; s3 -= carry3 << 21;
 3397|    124|  carry5 = (s5 + (1<<20)) >> 21; s6 += carry5; s5 -= carry5 << 21;
 3398|    124|  carry7 = (s7 + (1<<20)) >> 21; s8 += carry7; s7 -= carry7 << 21;
 3399|    124|  carry9 = (s9 + (1<<20)) >> 21; s10 += carry9; s9 -= carry9 << 21;
 3400|    124|  carry11 = (s11 + (1<<20)) >> 21; s12 += carry11; s11 -= carry11 << 21;
 3401|       |
 3402|    124|  s0 += s12 * 666643;
 3403|    124|  s1 += s12 * 470296;
 3404|    124|  s2 += s12 * 654183;
 3405|    124|  s3 -= s12 * 997805;
 3406|    124|  s4 += s12 * 136657;
 3407|    124|  s5 -= s12 * 683901;
 3408|    124|  s12 = 0;
 3409|       |
 3410|    124|  carry0 = s0 >> 21; s1 += carry0; s0 -= carry0 << 21;
 3411|    124|  carry1 = s1 >> 21; s2 += carry1; s1 -= carry1 << 21;
 3412|    124|  carry2 = s2 >> 21; s3 += carry2; s2 -= carry2 << 21;
 3413|    124|  carry3 = s3 >> 21; s4 += carry3; s3 -= carry3 << 21;
 3414|    124|  carry4 = s4 >> 21; s5 += carry4; s4 -= carry4 << 21;
 3415|    124|  carry5 = s5 >> 21; s6 += carry5; s5 -= carry5 << 21;
 3416|    124|  carry6 = s6 >> 21; s7 += carry6; s6 -= carry6 << 21;
 3417|    124|  carry7 = s7 >> 21; s8 += carry7; s7 -= carry7 << 21;
 3418|    124|  carry8 = s8 >> 21; s9 += carry8; s8 -= carry8 << 21;
 3419|    124|  carry9 = s9 >> 21; s10 += carry9; s9 -= carry9 << 21;
 3420|    124|  carry10 = s10 >> 21; s11 += carry10; s10 -= carry10 << 21;
 3421|    124|  carry11 = s11 >> 21; s12 += carry11; s11 -= carry11 << 21;
 3422|       |
 3423|    124|  s0 += s12 * 666643;
 3424|    124|  s1 += s12 * 470296;
 3425|    124|  s2 += s12 * 654183;
 3426|    124|  s3 -= s12 * 997805;
 3427|    124|  s4 += s12 * 136657;
 3428|    124|  s5 -= s12 * 683901;
 3429|       |
 3430|    124|  carry0 = s0 >> 21; s1 += carry0; s0 -= carry0 << 21;
 3431|    124|  carry1 = s1 >> 21; s2 += carry1; s1 -= carry1 << 21;
 3432|    124|  carry2 = s2 >> 21; s3 += carry2; s2 -= carry2 << 21;
 3433|    124|  carry3 = s3 >> 21; s4 += carry3; s3 -= carry3 << 21;
 3434|    124|  carry4 = s4 >> 21; s5 += carry4; s4 -= carry4 << 21;
 3435|    124|  carry5 = s5 >> 21; s6 += carry5; s5 -= carry5 << 21;
 3436|    124|  carry6 = s6 >> 21; s7 += carry6; s6 -= carry6 << 21;
 3437|    124|  carry7 = s7 >> 21; s8 += carry7; s7 -= carry7 << 21;
 3438|    124|  carry8 = s8 >> 21; s9 += carry8; s8 -= carry8 << 21;
 3439|    124|  carry9 = s9 >> 21; s10 += carry9; s9 -= carry9 << 21;
 3440|    124|  carry10 = s10 >> 21; s11 += carry10; s10 -= carry10 << 21;
 3441|       |
 3442|    124|  s[0] = s0 >> 0;
 3443|    124|  s[1] = s0 >> 8;
 3444|    124|  s[2] = (s0 >> 16) | (s1 << 5);
 3445|    124|  s[3] = s1 >> 3;
 3446|    124|  s[4] = s1 >> 11;
 3447|    124|  s[5] = (s1 >> 19) | (s2 << 2);
 3448|    124|  s[6] = s2 >> 6;
 3449|    124|  s[7] = (s2 >> 14) | (s3 << 7);
 3450|    124|  s[8] = s3 >> 1;
 3451|    124|  s[9] = s3 >> 9;
 3452|    124|  s[10] = (s3 >> 17) | (s4 << 4);
 3453|    124|  s[11] = s4 >> 4;
 3454|    124|  s[12] = s4 >> 12;
 3455|    124|  s[13] = (s4 >> 20) | (s5 << 1);
 3456|    124|  s[14] = s5 >> 7;
 3457|    124|  s[15] = (s5 >> 15) | (s6 << 6);
 3458|    124|  s[16] = s6 >> 2;
 3459|    124|  s[17] = s6 >> 10;
 3460|    124|  s[18] = (s6 >> 18) | (s7 << 3);
 3461|    124|  s[19] = s7 >> 5;
 3462|    124|  s[20] = s7 >> 13;
 3463|    124|  s[21] = s8 >> 0;
 3464|    124|  s[22] = s8 >> 8;
 3465|    124|  s[23] = (s8 >> 16) | (s9 << 5);
 3466|    124|  s[24] = s9 >> 3;
 3467|    124|  s[25] = s9 >> 11;
 3468|    124|  s[26] = (s9 >> 19) | (s10 << 2);
 3469|    124|  s[27] = s10 >> 6;
 3470|    124|  s[28] = (s10 >> 14) | (s11 << 7);
 3471|    124|  s[29] = s11 >> 1;
 3472|    124|  s[30] = s11 >> 9;
 3473|    124|  s[31] = s11 >> 17;
 3474|    124|}
sc_muladd:
 3488|    128|void sc_muladd(unsigned char *s, const unsigned char *a, const unsigned char *b, const unsigned char *c) {
 3489|    128|  int64_t a0 = 2097151 & load_3(a);
 3490|    128|  int64_t a1 = 2097151 & (load_4(a + 2) >> 5);
 3491|    128|  int64_t a2 = 2097151 & (load_3(a + 5) >> 2);
 3492|    128|  int64_t a3 = 2097151 & (load_4(a + 7) >> 7);
 3493|    128|  int64_t a4 = 2097151 & (load_4(a + 10) >> 4);
 3494|    128|  int64_t a5 = 2097151 & (load_3(a + 13) >> 1);
 3495|    128|  int64_t a6 = 2097151 & (load_4(a + 15) >> 6);
 3496|    128|  int64_t a7 = 2097151 & (load_3(a + 18) >> 3);
 3497|    128|  int64_t a8 = 2097151 & load_3(a + 21);
 3498|    128|  int64_t a9 = 2097151 & (load_4(a + 23) >> 5);
 3499|    128|  int64_t a10 = 2097151 & (load_3(a + 26) >> 2);
 3500|    128|  int64_t a11 = (load_4(a + 28) >> 7);
 3501|    128|  int64_t b0 = 2097151 & load_3(b);
 3502|    128|  int64_t b1 = 2097151 & (load_4(b + 2) >> 5);
 3503|    128|  int64_t b2 = 2097151 & (load_3(b + 5) >> 2);
 3504|    128|  int64_t b3 = 2097151 & (load_4(b + 7) >> 7);
 3505|    128|  int64_t b4 = 2097151 & (load_4(b + 10) >> 4);
 3506|    128|  int64_t b5 = 2097151 & (load_3(b + 13) >> 1);
 3507|    128|  int64_t b6 = 2097151 & (load_4(b + 15) >> 6);
 3508|    128|  int64_t b7 = 2097151 & (load_3(b + 18) >> 3);
 3509|    128|  int64_t b8 = 2097151 & load_3(b + 21);
 3510|    128|  int64_t b9 = 2097151 & (load_4(b + 23) >> 5);
 3511|    128|  int64_t b10 = 2097151 & (load_3(b + 26) >> 2);
 3512|    128|  int64_t b11 = (load_4(b + 28) >> 7);
 3513|    128|  int64_t c0 = 2097151 & load_3(c);
 3514|    128|  int64_t c1 = 2097151 & (load_4(c + 2) >> 5);
 3515|    128|  int64_t c2 = 2097151 & (load_3(c + 5) >> 2);
 3516|    128|  int64_t c3 = 2097151 & (load_4(c + 7) >> 7);
 3517|    128|  int64_t c4 = 2097151 & (load_4(c + 10) >> 4);
 3518|    128|  int64_t c5 = 2097151 & (load_3(c + 13) >> 1);
 3519|    128|  int64_t c6 = 2097151 & (load_4(c + 15) >> 6);
 3520|    128|  int64_t c7 = 2097151 & (load_3(c + 18) >> 3);
 3521|    128|  int64_t c8 = 2097151 & load_3(c + 21);
 3522|    128|  int64_t c9 = 2097151 & (load_4(c + 23) >> 5);
 3523|    128|  int64_t c10 = 2097151 & (load_3(c + 26) >> 2);
 3524|    128|  int64_t c11 = (load_4(c + 28) >> 7);
 3525|    128|  int64_t s0;
 3526|    128|  int64_t s1;
 3527|    128|  int64_t s2;
 3528|    128|  int64_t s3;
 3529|    128|  int64_t s4;
 3530|    128|  int64_t s5;
 3531|    128|  int64_t s6;
 3532|    128|  int64_t s7;
 3533|    128|  int64_t s8;
 3534|    128|  int64_t s9;
 3535|    128|  int64_t s10;
 3536|    128|  int64_t s11;
 3537|    128|  int64_t s12;
 3538|    128|  int64_t s13;
 3539|    128|  int64_t s14;
 3540|    128|  int64_t s15;
 3541|    128|  int64_t s16;
 3542|    128|  int64_t s17;
 3543|    128|  int64_t s18;
 3544|    128|  int64_t s19;
 3545|    128|  int64_t s20;
 3546|    128|  int64_t s21;
 3547|    128|  int64_t s22;
 3548|    128|  int64_t s23;
 3549|    128|  int64_t carry0;
 3550|    128|  int64_t carry1;
 3551|    128|  int64_t carry2;
 3552|    128|  int64_t carry3;
 3553|    128|  int64_t carry4;
 3554|    128|  int64_t carry5;
 3555|    128|  int64_t carry6;
 3556|    128|  int64_t carry7;
 3557|    128|  int64_t carry8;
 3558|    128|  int64_t carry9;
 3559|    128|  int64_t carry10;
 3560|    128|  int64_t carry11;
 3561|    128|  int64_t carry12;
 3562|    128|  int64_t carry13;
 3563|    128|  int64_t carry14;
 3564|    128|  int64_t carry15;
 3565|    128|  int64_t carry16;
 3566|    128|  int64_t carry17;
 3567|    128|  int64_t carry18;
 3568|    128|  int64_t carry19;
 3569|    128|  int64_t carry20;
 3570|    128|  int64_t carry21;
 3571|    128|  int64_t carry22;
 3572|       |
 3573|    128|  s0 = c0 + a0*b0;
 3574|    128|  s1 = c1 + (a0*b1 + a1*b0);
 3575|    128|  s2 = c2 + (a0*b2 + a1*b1 + a2*b0);
 3576|    128|  s3 = c3 + (a0*b3 + a1*b2 + a2*b1 + a3*b0);
 3577|    128|  s4 = c4 + (a0*b4 + a1*b3 + a2*b2 + a3*b1 + a4*b0);
 3578|    128|  s5 = c5 + (a0*b5 + a1*b4 + a2*b3 + a3*b2 + a4*b1 + a5*b0);
 3579|    128|  s6 = c6 + (a0*b6 + a1*b5 + a2*b4 + a3*b3 + a4*b2 + a5*b1 + a6*b0);
 3580|    128|  s7 = c7 + (a0*b7 + a1*b6 + a2*b5 + a3*b4 + a4*b3 + a5*b2 + a6*b1 + a7*b0);
 3581|    128|  s8 = c8 + (a0*b8 + a1*b7 + a2*b6 + a3*b5 + a4*b4 + a5*b3 + a6*b2 + a7*b1 + a8*b0);
 3582|    128|  s9 = c9 + (a0*b9 + a1*b8 + a2*b7 + a3*b6 + a4*b5 + a5*b4 + a6*b3 + a7*b2 + a8*b1 + a9*b0);
 3583|    128|  s10 = c10 + (a0*b10 + a1*b9 + a2*b8 + a3*b7 + a4*b6 + a5*b5 + a6*b4 + a7*b3 + a8*b2 + a9*b1 + a10*b0);
 3584|    128|  s11 = c11 + (a0*b11 + a1*b10 + a2*b9 + a3*b8 + a4*b7 + a5*b6 + a6*b5 + a7*b4 + a8*b3 + a9*b2 + a10*b1 + a11*b0);
 3585|    128|  s12 = (a1*b11 + a2*b10 + a3*b9 + a4*b8 + a5*b7 + a6*b6 + a7*b5 + a8*b4 + a9*b3 + a10*b2 + a11*b1);
 3586|    128|  s13 = (a2*b11 + a3*b10 + a4*b9 + a5*b8 + a6*b7 + a7*b6 + a8*b5 + a9*b4 + a10*b3 + a11*b2);
 3587|    128|  s14 = (a3*b11 + a4*b10 + a5*b9 + a6*b8 + a7*b7 + a8*b6 + a9*b5 + a10*b4 + a11*b3);
 3588|    128|  s15 = (a4*b11 + a5*b10 + a6*b9 + a7*b8 + a8*b7 + a9*b6 + a10*b5 + a11*b4);
 3589|    128|  s16 = (a5*b11 + a6*b10 + a7*b9 + a8*b8 + a9*b7 + a10*b6 + a11*b5);
 3590|    128|  s17 = (a6*b11 + a7*b10 + a8*b9 + a9*b8 + a10*b7 + a11*b6);
 3591|    128|  s18 = (a7*b11 + a8*b10 + a9*b9 + a10*b8 + a11*b7);
 3592|    128|  s19 = (a8*b11 + a9*b10 + a10*b9 + a11*b8);
 3593|    128|  s20 = (a9*b11 + a10*b10 + a11*b9);
 3594|    128|  s21 = (a10*b11 + a11*b10);
 3595|    128|  s22 = a11*b11;
 3596|    128|  s23 = 0;
 3597|       |
 3598|    128|  carry0 = (s0 + (1<<20)) >> 21; s1 += carry0; s0 -= carry0 << 21;
 3599|    128|  carry2 = (s2 + (1<<20)) >> 21; s3 += carry2; s2 -= carry2 << 21;
 3600|    128|  carry4 = (s4 + (1<<20)) >> 21; s5 += carry4; s4 -= carry4 << 21;
 3601|    128|  carry6 = (s6 + (1<<20)) >> 21; s7 += carry6; s6 -= carry6 << 21;
 3602|    128|  carry8 = (s8 + (1<<20)) >> 21; s9 += carry8; s8 -= carry8 << 21;
 3603|    128|  carry10 = (s10 + (1<<20)) >> 21; s11 += carry10; s10 -= carry10 << 21;
 3604|    128|  carry12 = (s12 + (1<<20)) >> 21; s13 += carry12; s12 -= carry12 << 21;
 3605|    128|  carry14 = (s14 + (1<<20)) >> 21; s15 += carry14; s14 -= carry14 << 21;
 3606|    128|  carry16 = (s16 + (1<<20)) >> 21; s17 += carry16; s16 -= carry16 << 21;
 3607|    128|  carry18 = (s18 + (1<<20)) >> 21; s19 += carry18; s18 -= carry18 << 21;
 3608|    128|  carry20 = (s20 + (1<<20)) >> 21; s21 += carry20; s20 -= carry20 << 21;
 3609|    128|  carry22 = (s22 + (1<<20)) >> 21; s23 += carry22; s22 -= carry22 << 21;
 3610|       |
 3611|    128|  carry1 = (s1 + (1<<20)) >> 21; s2 += carry1; s1 -= carry1 << 21;
 3612|    128|  carry3 = (s3 + (1<<20)) >> 21; s4 += carry3; s3 -= carry3 << 21;
 3613|    128|  carry5 = (s5 + (1<<20)) >> 21; s6 += carry5; s5 -= carry5 << 21;
 3614|    128|  carry7 = (s7 + (1<<20)) >> 21; s8 += carry7; s7 -= carry7 << 21;
 3615|    128|  carry9 = (s9 + (1<<20)) >> 21; s10 += carry9; s9 -= carry9 << 21;
 3616|    128|  carry11 = (s11 + (1<<20)) >> 21; s12 += carry11; s11 -= carry11 << 21;
 3617|    128|  carry13 = (s13 + (1<<20)) >> 21; s14 += carry13; s13 -= carry13 << 21;
 3618|    128|  carry15 = (s15 + (1<<20)) >> 21; s16 += carry15; s15 -= carry15 << 21;
 3619|    128|  carry17 = (s17 + (1<<20)) >> 21; s18 += carry17; s17 -= carry17 << 21;
 3620|    128|  carry19 = (s19 + (1<<20)) >> 21; s20 += carry19; s19 -= carry19 << 21;
 3621|    128|  carry21 = (s21 + (1<<20)) >> 21; s22 += carry21; s21 -= carry21 << 21;
 3622|       |
 3623|    128|  s11 += s23 * 666643;
 3624|    128|  s12 += s23 * 470296;
 3625|    128|  s13 += s23 * 654183;
 3626|    128|  s14 -= s23 * 997805;
 3627|    128|  s15 += s23 * 136657;
 3628|    128|  s16 -= s23 * 683901;
 3629|       |
 3630|    128|  s10 += s22 * 666643;
 3631|    128|  s11 += s22 * 470296;
 3632|    128|  s12 += s22 * 654183;
 3633|    128|  s13 -= s22 * 997805;
 3634|    128|  s14 += s22 * 136657;
 3635|    128|  s15 -= s22 * 683901;
 3636|       |
 3637|    128|  s9 += s21 * 666643;
 3638|    128|  s10 += s21 * 470296;
 3639|    128|  s11 += s21 * 654183;
 3640|    128|  s12 -= s21 * 997805;
 3641|    128|  s13 += s21 * 136657;
 3642|    128|  s14 -= s21 * 683901;
 3643|       |
 3644|    128|  s8 += s20 * 666643;
 3645|    128|  s9 += s20 * 470296;
 3646|    128|  s10 += s20 * 654183;
 3647|    128|  s11 -= s20 * 997805;
 3648|    128|  s12 += s20 * 136657;
 3649|    128|  s13 -= s20 * 683901;
 3650|       |
 3651|    128|  s7 += s19 * 666643;
 3652|    128|  s8 += s19 * 470296;
 3653|    128|  s9 += s19 * 654183;
 3654|    128|  s10 -= s19 * 997805;
 3655|    128|  s11 += s19 * 136657;
 3656|    128|  s12 -= s19 * 683901;
 3657|       |
 3658|    128|  s6 += s18 * 666643;
 3659|    128|  s7 += s18 * 470296;
 3660|    128|  s8 += s18 * 654183;
 3661|    128|  s9 -= s18 * 997805;
 3662|    128|  s10 += s18 * 136657;
 3663|    128|  s11 -= s18 * 683901;
 3664|       |
 3665|    128|  carry6 = (s6 + (1<<20)) >> 21; s7 += carry6; s6 -= carry6 << 21;
 3666|    128|  carry8 = (s8 + (1<<20)) >> 21; s9 += carry8; s8 -= carry8 << 21;
 3667|    128|  carry10 = (s10 + (1<<20)) >> 21; s11 += carry10; s10 -= carry10 << 21;
 3668|    128|  carry12 = (s12 + (1<<20)) >> 21; s13 += carry12; s12 -= carry12 << 21;
 3669|    128|  carry14 = (s14 + (1<<20)) >> 21; s15 += carry14; s14 -= carry14 << 21;
 3670|    128|  carry16 = (s16 + (1<<20)) >> 21; s17 += carry16; s16 -= carry16 << 21;
 3671|       |
 3672|    128|  carry7 = (s7 + (1<<20)) >> 21; s8 += carry7; s7 -= carry7 << 21;
 3673|    128|  carry9 = (s9 + (1<<20)) >> 21; s10 += carry9; s9 -= carry9 << 21;
 3674|    128|  carry11 = (s11 + (1<<20)) >> 21; s12 += carry11; s11 -= carry11 << 21;
 3675|    128|  carry13 = (s13 + (1<<20)) >> 21; s14 += carry13; s13 -= carry13 << 21;
 3676|    128|  carry15 = (s15 + (1<<20)) >> 21; s16 += carry15; s15 -= carry15 << 21;
 3677|       |
 3678|    128|  s5 += s17 * 666643;
 3679|    128|  s6 += s17 * 470296;
 3680|    128|  s7 += s17 * 654183;
 3681|    128|  s8 -= s17 * 997805;
 3682|    128|  s9 += s17 * 136657;
 3683|    128|  s10 -= s17 * 683901;
 3684|       |
 3685|    128|  s4 += s16 * 666643;
 3686|    128|  s5 += s16 * 470296;
 3687|    128|  s6 += s16 * 654183;
 3688|    128|  s7 -= s16 * 997805;
 3689|    128|  s8 += s16 * 136657;
 3690|    128|  s9 -= s16 * 683901;
 3691|       |
 3692|    128|  s3 += s15 * 666643;
 3693|    128|  s4 += s15 * 470296;
 3694|    128|  s5 += s15 * 654183;
 3695|    128|  s6 -= s15 * 997805;
 3696|    128|  s7 += s15 * 136657;
 3697|    128|  s8 -= s15 * 683901;
 3698|       |
 3699|    128|  s2 += s14 * 666643;
 3700|    128|  s3 += s14 * 470296;
 3701|    128|  s4 += s14 * 654183;
 3702|    128|  s5 -= s14 * 997805;
 3703|    128|  s6 += s14 * 136657;
 3704|    128|  s7 -= s14 * 683901;
 3705|       |
 3706|    128|  s1 += s13 * 666643;
 3707|    128|  s2 += s13 * 470296;
 3708|    128|  s3 += s13 * 654183;
 3709|    128|  s4 -= s13 * 997805;
 3710|    128|  s5 += s13 * 136657;
 3711|    128|  s6 -= s13 * 683901;
 3712|       |
 3713|    128|  s0 += s12 * 666643;
 3714|    128|  s1 += s12 * 470296;
 3715|    128|  s2 += s12 * 654183;
 3716|    128|  s3 -= s12 * 997805;
 3717|    128|  s4 += s12 * 136657;
 3718|    128|  s5 -= s12 * 683901;
 3719|    128|  s12 = 0;
 3720|       |
 3721|    128|  carry0 = (s0 + (1<<20)) >> 21; s1 += carry0; s0 -= carry0 << 21;
 3722|    128|  carry2 = (s2 + (1<<20)) >> 21; s3 += carry2; s2 -= carry2 << 21;
 3723|    128|  carry4 = (s4 + (1<<20)) >> 21; s5 += carry4; s4 -= carry4 << 21;
 3724|    128|  carry6 = (s6 + (1<<20)) >> 21; s7 += carry6; s6 -= carry6 << 21;
 3725|    128|  carry8 = (s8 + (1<<20)) >> 21; s9 += carry8; s8 -= carry8 << 21;
 3726|    128|  carry10 = (s10 + (1<<20)) >> 21; s11 += carry10; s10 -= carry10 << 21;
 3727|       |
 3728|    128|  carry1 = (s1 + (1<<20)) >> 21; s2 += carry1; s1 -= carry1 << 21;
 3729|    128|  carry3 = (s3 + (1<<20)) >> 21; s4 += carry3; s3 -= carry3 << 21;
 3730|    128|  carry5 = (s5 + (1<<20)) >> 21; s6 += carry5; s5 -= carry5 << 21;
 3731|    128|  carry7 = (s7 + (1<<20)) >> 21; s8 += carry7; s7 -= carry7 << 21;
 3732|    128|  carry9 = (s9 + (1<<20)) >> 21; s10 += carry9; s9 -= carry9 << 21;
 3733|    128|  carry11 = (s11 + (1<<20)) >> 21; s12 += carry11; s11 -= carry11 << 21;
 3734|       |
 3735|    128|  s0 += s12 * 666643;
 3736|    128|  s1 += s12 * 470296;
 3737|    128|  s2 += s12 * 654183;
 3738|    128|  s3 -= s12 * 997805;
 3739|    128|  s4 += s12 * 136657;
 3740|    128|  s5 -= s12 * 683901;
 3741|    128|  s12 = 0;
 3742|       |
 3743|    128|  carry0 = s0 >> 21; s1 += carry0; s0 -= carry0 << 21;
 3744|    128|  carry1 = s1 >> 21; s2 += carry1; s1 -= carry1 << 21;
 3745|    128|  carry2 = s2 >> 21; s3 += carry2; s2 -= carry2 << 21;
 3746|    128|  carry3 = s3 >> 21; s4 += carry3; s3 -= carry3 << 21;
 3747|    128|  carry4 = s4 >> 21; s5 += carry4; s4 -= carry4 << 21;
 3748|    128|  carry5 = s5 >> 21; s6 += carry5; s5 -= carry5 << 21;
 3749|    128|  carry6 = s6 >> 21; s7 += carry6; s6 -= carry6 << 21;
 3750|    128|  carry7 = s7 >> 21; s8 += carry7; s7 -= carry7 << 21;
 3751|    128|  carry8 = s8 >> 21; s9 += carry8; s8 -= carry8 << 21;
 3752|    128|  carry9 = s9 >> 21; s10 += carry9; s9 -= carry9 << 21;
 3753|    128|  carry10 = s10 >> 21; s11 += carry10; s10 -= carry10 << 21;
 3754|    128|  carry11 = s11 >> 21; s12 += carry11; s11 -= carry11 << 21;
 3755|       |
 3756|    128|  s0 += s12 * 666643;
 3757|    128|  s1 += s12 * 470296;
 3758|    128|  s2 += s12 * 654183;
 3759|    128|  s3 -= s12 * 997805;
 3760|    128|  s4 += s12 * 136657;
 3761|    128|  s5 -= s12 * 683901;
 3762|       |
 3763|    128|  carry0 = s0 >> 21; s1 += carry0; s0 -= carry0 << 21;
 3764|    128|  carry1 = s1 >> 21; s2 += carry1; s1 -= carry1 << 21;
 3765|    128|  carry2 = s2 >> 21; s3 += carry2; s2 -= carry2 << 21;
 3766|    128|  carry3 = s3 >> 21; s4 += carry3; s3 -= carry3 << 21;
 3767|    128|  carry4 = s4 >> 21; s5 += carry4; s4 -= carry4 << 21;
 3768|    128|  carry5 = s5 >> 21; s6 += carry5; s5 -= carry5 << 21;
 3769|    128|  carry6 = s6 >> 21; s7 += carry6; s6 -= carry6 << 21;
 3770|    128|  carry7 = s7 >> 21; s8 += carry7; s7 -= carry7 << 21;
 3771|    128|  carry8 = s8 >> 21; s9 += carry8; s8 -= carry8 << 21;
 3772|    128|  carry9 = s9 >> 21; s10 += carry9; s9 -= carry9 << 21;
 3773|    128|  carry10 = s10 >> 21; s11 += carry10; s10 -= carry10 << 21;
 3774|       |
 3775|    128|  s[0] = s0 >> 0;
 3776|    128|  s[1] = s0 >> 8;
 3777|    128|  s[2] = (s0 >> 16) | (s1 << 5);
 3778|    128|  s[3] = s1 >> 3;
 3779|    128|  s[4] = s1 >> 11;
 3780|    128|  s[5] = (s1 >> 19) | (s2 << 2);
 3781|    128|  s[6] = s2 >> 6;
 3782|    128|  s[7] = (s2 >> 14) | (s3 << 7);
 3783|    128|  s[8] = s3 >> 1;
 3784|    128|  s[9] = s3 >> 9;
 3785|    128|  s[10] = (s3 >> 17) | (s4 << 4);
 3786|    128|  s[11] = s4 >> 4;
 3787|    128|  s[12] = s4 >> 12;
 3788|    128|  s[13] = (s4 >> 20) | (s5 << 1);
 3789|    128|  s[14] = s5 >> 7;
 3790|    128|  s[15] = (s5 >> 15) | (s6 << 6);
 3791|    128|  s[16] = s6 >> 2;
 3792|    128|  s[17] = s6 >> 10;
 3793|    128|  s[18] = (s6 >> 18) | (s7 << 3);
 3794|    128|  s[19] = s7 >> 5;
 3795|    128|  s[20] = s7 >> 13;
 3796|    128|  s[21] = s8 >> 0;
 3797|    128|  s[22] = s8 >> 8;
 3798|    128|  s[23] = (s8 >> 16) | (s9 << 5);
 3799|    128|  s[24] = s9 >> 3;
 3800|    128|  s[25] = s9 >> 11;
 3801|    128|  s[26] = (s9 >> 19) | (s10 << 2);
 3802|    128|  s[27] = s10 >> 6;
 3803|    128|  s[28] = (s10 >> 14) | (s11 << 7);
 3804|    128|  s[29] = s11 >> 1;
 3805|    128|  s[30] = s11 >> 9;
 3806|    128|  s[31] = s11 >> 17;
 3807|    128|}
sc_check:
 3813|  5.87k|int sc_check(const unsigned char *s) {
 3814|  5.87k|  int64_t s0 = load_4(s);
 3815|  5.87k|  int64_t s1 = load_4(s + 4);
 3816|  5.87k|  int64_t s2 = load_4(s + 8);
 3817|  5.87k|  int64_t s3 = load_4(s + 12);
 3818|  5.87k|  int64_t s4 = load_4(s + 16);
 3819|  5.87k|  int64_t s5 = load_4(s + 20);
 3820|  5.87k|  int64_t s6 = load_4(s + 24);
 3821|  5.87k|  int64_t s7 = load_4(s + 28);
 3822|  5.87k|  return (signum(1559614444 - s0) + (signum(1477600026 - s1) << 1) + (signum(2734136534 - s2) << 2) + (signum(350157278 - s3) << 3) + (signum(-s4) << 4) + (signum(-s5) << 5) + (signum(-s6) << 6) + (signum(268435456 - s7) << 7)) >> 8;
 3823|  5.87k|}
sc_isnonzero:
 3825|   115k|int sc_isnonzero(const unsigned char *s) {
 3826|   115k|  return (((int) (s[0] | s[1] | s[2] | s[3] | s[4] | s[5] | s[6] | s[7] | s[8] |
 3827|   115k|    s[9] | s[10] | s[11] | s[12] | s[13] | s[14] | s[15] | s[16] | s[17] |
 3828|   115k|    s[18] | s[19] | s[20] | s[21] | s[22] | s[23] | s[24] | s[25] | s[26] |
 3829|   115k|    s[27] | s[28] | s[29] | s[30] | s[31]) - 1) >> 8) + 1;
 3830|   115k|}
crypto-ops.c:fe_sq:
  657|  29.3M|static void fe_sq(fe h, const fe f) {
  658|  29.3M|  int32_t f0 = f[0];
  659|  29.3M|  int32_t f1 = f[1];
  660|  29.3M|  int32_t f2 = f[2];
  661|  29.3M|  int32_t f3 = f[3];
  662|  29.3M|  int32_t f4 = f[4];
  663|  29.3M|  int32_t f5 = f[5];
  664|  29.3M|  int32_t f6 = f[6];
  665|  29.3M|  int32_t f7 = f[7];
  666|  29.3M|  int32_t f8 = f[8];
  667|  29.3M|  int32_t f9 = f[9];
  668|  29.3M|  int32_t f0_2 = 2 * f0;
  669|  29.3M|  int32_t f1_2 = 2 * f1;
  670|  29.3M|  int32_t f2_2 = 2 * f2;
  671|  29.3M|  int32_t f3_2 = 2 * f3;
  672|  29.3M|  int32_t f4_2 = 2 * f4;
  673|  29.3M|  int32_t f5_2 = 2 * f5;
  674|  29.3M|  int32_t f6_2 = 2 * f6;
  675|  29.3M|  int32_t f7_2 = 2 * f7;
  676|  29.3M|  int32_t f5_38 = 38 * f5; /* 1.959375*2^30 */
  677|  29.3M|  int32_t f6_19 = 19 * f6; /* 1.959375*2^30 */
  678|  29.3M|  int32_t f7_38 = 38 * f7; /* 1.959375*2^30 */
  679|  29.3M|  int32_t f8_19 = 19 * f8; /* 1.959375*2^30 */
  680|  29.3M|  int32_t f9_38 = 38 * f9; /* 1.959375*2^30 */
  681|  29.3M|  int64_t f0f0    = f0   * (int64_t) f0;
  682|  29.3M|  int64_t f0f1_2  = f0_2 * (int64_t) f1;
  683|  29.3M|  int64_t f0f2_2  = f0_2 * (int64_t) f2;
  684|  29.3M|  int64_t f0f3_2  = f0_2 * (int64_t) f3;
  685|  29.3M|  int64_t f0f4_2  = f0_2 * (int64_t) f4;
  686|  29.3M|  int64_t f0f5_2  = f0_2 * (int64_t) f5;
  687|  29.3M|  int64_t f0f6_2  = f0_2 * (int64_t) f6;
  688|  29.3M|  int64_t f0f7_2  = f0_2 * (int64_t) f7;
  689|  29.3M|  int64_t f0f8_2  = f0_2 * (int64_t) f8;
  690|  29.3M|  int64_t f0f9_2  = f0_2 * (int64_t) f9;
  691|  29.3M|  int64_t f1f1_2  = f1_2 * (int64_t) f1;
  692|  29.3M|  int64_t f1f2_2  = f1_2 * (int64_t) f2;
  693|  29.3M|  int64_t f1f3_4  = f1_2 * (int64_t) f3_2;
  694|  29.3M|  int64_t f1f4_2  = f1_2 * (int64_t) f4;
  695|  29.3M|  int64_t f1f5_4  = f1_2 * (int64_t) f5_2;
  696|  29.3M|  int64_t f1f6_2  = f1_2 * (int64_t) f6;
  697|  29.3M|  int64_t f1f7_4  = f1_2 * (int64_t) f7_2;
  698|  29.3M|  int64_t f1f8_2  = f1_2 * (int64_t) f8;
  699|  29.3M|  int64_t f1f9_76 = f1_2 * (int64_t) f9_38;
  700|  29.3M|  int64_t f2f2    = f2   * (int64_t) f2;
  701|  29.3M|  int64_t f2f3_2  = f2_2 * (int64_t) f3;
  702|  29.3M|  int64_t f2f4_2  = f2_2 * (int64_t) f4;
  703|  29.3M|  int64_t f2f5_2  = f2_2 * (int64_t) f5;
  704|  29.3M|  int64_t f2f6_2  = f2_2 * (int64_t) f6;
  705|  29.3M|  int64_t f2f7_2  = f2_2 * (int64_t) f7;
  706|  29.3M|  int64_t f2f8_38 = f2_2 * (int64_t) f8_19;
  707|  29.3M|  int64_t f2f9_38 = f2   * (int64_t) f9_38;
  708|  29.3M|  int64_t f3f3_2  = f3_2 * (int64_t) f3;
  709|  29.3M|  int64_t f3f4_2  = f3_2 * (int64_t) f4;
  710|  29.3M|  int64_t f3f5_4  = f3_2 * (int64_t) f5_2;
  711|  29.3M|  int64_t f3f6_2  = f3_2 * (int64_t) f6;
  712|  29.3M|  int64_t f3f7_76 = f3_2 * (int64_t) f7_38;
  713|  29.3M|  int64_t f3f8_38 = f3_2 * (int64_t) f8_19;
  714|  29.3M|  int64_t f3f9_76 = f3_2 * (int64_t) f9_38;
  715|  29.3M|  int64_t f4f4    = f4   * (int64_t) f4;
  716|  29.3M|  int64_t f4f5_2  = f4_2 * (int64_t) f5;
  717|  29.3M|  int64_t f4f6_38 = f4_2 * (int64_t) f6_19;
  718|  29.3M|  int64_t f4f7_38 = f4   * (int64_t) f7_38;
  719|  29.3M|  int64_t f4f8_38 = f4_2 * (int64_t) f8_19;
  720|  29.3M|  int64_t f4f9_38 = f4   * (int64_t) f9_38;
  721|  29.3M|  int64_t f5f5_38 = f5   * (int64_t) f5_38;
  722|  29.3M|  int64_t f5f6_38 = f5_2 * (int64_t) f6_19;
  723|  29.3M|  int64_t f5f7_76 = f5_2 * (int64_t) f7_38;
  724|  29.3M|  int64_t f5f8_38 = f5_2 * (int64_t) f8_19;
  725|  29.3M|  int64_t f5f9_76 = f5_2 * (int64_t) f9_38;
  726|  29.3M|  int64_t f6f6_19 = f6   * (int64_t) f6_19;
  727|  29.3M|  int64_t f6f7_38 = f6   * (int64_t) f7_38;
  728|  29.3M|  int64_t f6f8_38 = f6_2 * (int64_t) f8_19;
  729|  29.3M|  int64_t f6f9_38 = f6   * (int64_t) f9_38;
  730|  29.3M|  int64_t f7f7_38 = f7   * (int64_t) f7_38;
  731|  29.3M|  int64_t f7f8_38 = f7_2 * (int64_t) f8_19;
  732|  29.3M|  int64_t f7f9_76 = f7_2 * (int64_t) f9_38;
  733|  29.3M|  int64_t f8f8_19 = f8   * (int64_t) f8_19;
  734|  29.3M|  int64_t f8f9_38 = f8   * (int64_t) f9_38;
  735|  29.3M|  int64_t f9f9_38 = f9   * (int64_t) f9_38;
  736|  29.3M|  int64_t h0 = f0f0  +f1f9_76+f2f8_38+f3f7_76+f4f6_38+f5f5_38;
  737|  29.3M|  int64_t h1 = f0f1_2+f2f9_38+f3f8_38+f4f7_38+f5f6_38;
  738|  29.3M|  int64_t h2 = f0f2_2+f1f1_2 +f3f9_76+f4f8_38+f5f7_76+f6f6_19;
  739|  29.3M|  int64_t h3 = f0f3_2+f1f2_2 +f4f9_38+f5f8_38+f6f7_38;
  740|  29.3M|  int64_t h4 = f0f4_2+f1f3_4 +f2f2   +f5f9_76+f6f8_38+f7f7_38;
  741|  29.3M|  int64_t h5 = f0f5_2+f1f4_2 +f2f3_2 +f6f9_38+f7f8_38;
  742|  29.3M|  int64_t h6 = f0f6_2+f1f5_4 +f2f4_2 +f3f3_2 +f7f9_76+f8f8_19;
  743|  29.3M|  int64_t h7 = f0f7_2+f1f6_2 +f2f5_2 +f3f4_2 +f8f9_38;
  744|  29.3M|  int64_t h8 = f0f8_2+f1f7_4 +f2f6_2 +f3f5_4 +f4f4   +f9f9_38;
  745|  29.3M|  int64_t h9 = f0f9_2+f1f8_2 +f2f7_2 +f3f6_2 +f4f5_2;
  746|  29.3M|  int64_t carry0;
  747|  29.3M|  int64_t carry1;
  748|  29.3M|  int64_t carry2;
  749|  29.3M|  int64_t carry3;
  750|  29.3M|  int64_t carry4;
  751|  29.3M|  int64_t carry5;
  752|  29.3M|  int64_t carry6;
  753|  29.3M|  int64_t carry7;
  754|  29.3M|  int64_t carry8;
  755|  29.3M|  int64_t carry9;
  756|       |
  757|  29.3M|  carry0 = (h0 + (int64_t) (1<<25)) >> 26; h1 += carry0; h0 -= carry0 << 26;
  758|  29.3M|  carry4 = (h4 + (int64_t) (1<<25)) >> 26; h5 += carry4; h4 -= carry4 << 26;
  759|       |
  760|  29.3M|  carry1 = (h1 + (int64_t) (1<<24)) >> 25; h2 += carry1; h1 -= carry1 << 25;
  761|  29.3M|  carry5 = (h5 + (int64_t) (1<<24)) >> 25; h6 += carry5; h5 -= carry5 << 25;
  762|       |
  763|  29.3M|  carry2 = (h2 + (int64_t) (1<<25)) >> 26; h3 += carry2; h2 -= carry2 << 26;
  764|  29.3M|  carry6 = (h6 + (int64_t) (1<<25)) >> 26; h7 += carry6; h6 -= carry6 << 26;
  765|       |
  766|  29.3M|  carry3 = (h3 + (int64_t) (1<<24)) >> 25; h4 += carry3; h3 -= carry3 << 25;
  767|  29.3M|  carry7 = (h7 + (int64_t) (1<<24)) >> 25; h8 += carry7; h7 -= carry7 << 25;
  768|       |
  769|  29.3M|  carry4 = (h4 + (int64_t) (1<<25)) >> 26; h5 += carry4; h4 -= carry4 << 26;
  770|  29.3M|  carry8 = (h8 + (int64_t) (1<<25)) >> 26; h9 += carry8; h8 -= carry8 << 26;
  771|       |
  772|  29.3M|  carry9 = (h9 + (int64_t) (1<<24)) >> 25; h0 += carry9 * 19; h9 -= carry9 << 25;
  773|       |
  774|  29.3M|  carry0 = (h0 + (int64_t) (1<<25)) >> 26; h1 += carry0; h0 -= carry0 << 26;
  775|       |
  776|  29.3M|  h[0] = h0;
  777|  29.3M|  h[1] = h1;
  778|  29.3M|  h[2] = h2;
  779|  29.3M|  h[3] = h3;
  780|  29.3M|  h[4] = h4;
  781|  29.3M|  h[5] = h5;
  782|  29.3M|  h[6] = h6;
  783|  29.3M|  h[7] = h7;
  784|  29.3M|  h[8] = h8;
  785|  29.3M|  h[9] = h9;
  786|  29.3M|}
crypto-ops.c:fe_sub:
  961|  22.3M|static void fe_sub(fe h, const fe f, const fe g) {
  962|  22.3M|  int32_t f0 = f[0];
  963|  22.3M|  int32_t f1 = f[1];
  964|  22.3M|  int32_t f2 = f[2];
  965|  22.3M|  int32_t f3 = f[3];
  966|  22.3M|  int32_t f4 = f[4];
  967|  22.3M|  int32_t f5 = f[5];
  968|  22.3M|  int32_t f6 = f[6];
  969|  22.3M|  int32_t f7 = f[7];
  970|  22.3M|  int32_t f8 = f[8];
  971|  22.3M|  int32_t f9 = f[9];
  972|  22.3M|  int32_t g0 = g[0];
  973|  22.3M|  int32_t g1 = g[1];
  974|  22.3M|  int32_t g2 = g[2];
  975|  22.3M|  int32_t g3 = g[3];
  976|  22.3M|  int32_t g4 = g[4];
  977|  22.3M|  int32_t g5 = g[5];
  978|  22.3M|  int32_t g6 = g[6];
  979|  22.3M|  int32_t g7 = g[7];
  980|  22.3M|  int32_t g8 = g[8];
  981|  22.3M|  int32_t g9 = g[9];
  982|  22.3M|  int32_t h0 = f0 - g0;
  983|  22.3M|  int32_t h1 = f1 - g1;
  984|  22.3M|  int32_t h2 = f2 - g2;
  985|  22.3M|  int32_t h3 = f3 - g3;
  986|  22.3M|  int32_t h4 = f4 - g4;
  987|  22.3M|  int32_t h5 = f5 - g5;
  988|  22.3M|  int32_t h6 = f6 - g6;
  989|  22.3M|  int32_t h7 = f7 - g7;
  990|  22.3M|  int32_t h8 = f8 - g8;
  991|  22.3M|  int32_t h9 = f9 - g9;
  992|  22.3M|  h[0] = h0;
  993|  22.3M|  h[1] = h1;
  994|  22.3M|  h[2] = h2;
  995|  22.3M|  h[3] = h3;
  996|  22.3M|  h[4] = h4;
  997|  22.3M|  h[5] = h5;
  998|  22.3M|  h[6] = h6;
  999|  22.3M|  h[7] = h7;
 1000|  22.3M|  h[8] = h8;
 1001|  22.3M|  h[9] = h9;
 1002|  22.3M|}
crypto-ops.c:fe_1:
   93|  14.2M|static void fe_1(fe h) {
   94|  14.2M|  h[0] = 1;
   95|  14.2M|  h[1] = 0;
   96|  14.2M|  h[2] = 0;
   97|  14.2M|  h[3] = 0;
   98|  14.2M|  h[4] = 0;
   99|  14.2M|  h[5] = 0;
  100|  14.2M|  h[6] = 0;
  101|  14.2M|  h[7] = 0;
  102|  14.2M|  h[8] = 0;
  103|  14.2M|  h[9] = 0;
  104|  14.2M|}
crypto-ops.c:fe_isnonzero:
  334|  1.07k|static int fe_isnonzero(const fe f) {
  335|  1.07k|  unsigned char s[32];
  336|  1.07k|  fe_tobytes(s, f);
  337|  1.07k|  return (((int) (s[0] | s[1] | s[2] | s[3] | s[4] | s[5] | s[6] | s[7] | s[8] |
  338|  1.07k|    s[9] | s[10] | s[11] | s[12] | s[13] | s[14] | s[15] | s[16] | s[17] |
  339|  1.07k|    s[18] | s[19] | s[20] | s[21] | s[22] | s[23] | s[24] | s[25] | s[26] |
  340|  1.07k|    s[27] | s[28] | s[29] | s[30] | s[31]) - 1) >> 8) + 1;
  341|  1.07k|}
crypto-ops.c:fe_isnegative:
  326|   110k|static int fe_isnegative(const fe f) {
  327|   110k|  unsigned char s[32];
  328|   110k|  fe_tobytes(s, f);
  329|   110k|  return s[0] & 1;
  330|   110k|}
crypto-ops.c:fe_neg:
  607|  7.02M|static void fe_neg(fe h, const fe f) {
  608|  7.02M|  int32_t f0 = f[0];
  609|  7.02M|  int32_t f1 = f[1];
  610|  7.02M|  int32_t f2 = f[2];
  611|  7.02M|  int32_t f3 = f[3];
  612|  7.02M|  int32_t f4 = f[4];
  613|  7.02M|  int32_t f5 = f[5];
  614|  7.02M|  int32_t f6 = f[6];
  615|  7.02M|  int32_t f7 = f[7];
  616|  7.02M|  int32_t f8 = f[8];
  617|  7.02M|  int32_t f9 = f[9];
  618|  7.02M|  int32_t h0 = -f0;
  619|  7.02M|  int32_t h1 = -f1;
  620|  7.02M|  int32_t h2 = -f2;
  621|  7.02M|  int32_t h3 = -f3;
  622|  7.02M|  int32_t h4 = -f4;
  623|  7.02M|  int32_t h5 = -f5;
  624|  7.02M|  int32_t h6 = -f6;
  625|  7.02M|  int32_t h7 = -f7;
  626|  7.02M|  int32_t h8 = -f8;
  627|  7.02M|  int32_t h9 = -f9;
  628|  7.02M|  h[0] = h0;
  629|  7.02M|  h[1] = h1;
  630|  7.02M|  h[2] = h2;
  631|  7.02M|  h[3] = h3;
  632|  7.02M|  h[4] = h4;
  633|  7.02M|  h[5] = h5;
  634|  7.02M|  h[6] = h6;
  635|  7.02M|  h[7] = h7;
  636|  7.02M|  h[8] = h8;
  637|  7.02M|  h[9] = h9;
  638|  7.02M|}
crypto-ops.c:ge_madd:
 1431|  7.01M|static void ge_madd(ge_p1p1 *r, const ge_p3 *p, const ge_precomp *q) {
 1432|  7.01M|  fe t0;
 1433|  7.01M|  fe_add(r->X, p->Y, p->X);
 1434|  7.01M|  fe_sub(r->Y, p->Y, p->X);
 1435|  7.01M|  fe_mul(r->Z, r->X, q->yplusx);
 1436|  7.01M|  fe_mul(r->Y, r->Y, q->yminusx);
 1437|  7.01M|  fe_mul(r->T, q->xy2d, p->T);
 1438|  7.01M|  fe_add(t0, p->Z, p->Z);
 1439|  7.01M|  fe_sub(r->X, r->Z, r->Y);
 1440|  7.01M|  fe_add(r->Y, r->Z, r->Y);
 1441|  7.01M|  fe_add(r->Z, t0, r->T);
 1442|  7.01M|  fe_sub(r->T, t0, r->T);
 1443|  7.01M|}
crypto-ops.c:fe_sq2:
  805|   438k|static void fe_sq2(fe h, const fe f) {
  806|   438k|  int32_t f0 = f[0];
  807|   438k|  int32_t f1 = f[1];
  808|   438k|  int32_t f2 = f[2];
  809|   438k|  int32_t f3 = f[3];
  810|   438k|  int32_t f4 = f[4];
  811|   438k|  int32_t f5 = f[5];
  812|   438k|  int32_t f6 = f[6];
  813|   438k|  int32_t f7 = f[7];
  814|   438k|  int32_t f8 = f[8];
  815|   438k|  int32_t f9 = f[9];
  816|   438k|  int32_t f0_2 = 2 * f0;
  817|   438k|  int32_t f1_2 = 2 * f1;
  818|   438k|  int32_t f2_2 = 2 * f2;
  819|   438k|  int32_t f3_2 = 2 * f3;
  820|   438k|  int32_t f4_2 = 2 * f4;
  821|   438k|  int32_t f5_2 = 2 * f5;
  822|   438k|  int32_t f6_2 = 2 * f6;
  823|   438k|  int32_t f7_2 = 2 * f7;
  824|   438k|  int32_t f5_38 = 38 * f5; /* 1.959375*2^30 */
  825|   438k|  int32_t f6_19 = 19 * f6; /* 1.959375*2^30 */
  826|   438k|  int32_t f7_38 = 38 * f7; /* 1.959375*2^30 */
  827|   438k|  int32_t f8_19 = 19 * f8; /* 1.959375*2^30 */
  828|   438k|  int32_t f9_38 = 38 * f9; /* 1.959375*2^30 */
  829|   438k|  int64_t f0f0    = f0   * (int64_t) f0;
  830|   438k|  int64_t f0f1_2  = f0_2 * (int64_t) f1;
  831|   438k|  int64_t f0f2_2  = f0_2 * (int64_t) f2;
  832|   438k|  int64_t f0f3_2  = f0_2 * (int64_t) f3;
  833|   438k|  int64_t f0f4_2  = f0_2 * (int64_t) f4;
  834|   438k|  int64_t f0f5_2  = f0_2 * (int64_t) f5;
  835|   438k|  int64_t f0f6_2  = f0_2 * (int64_t) f6;
  836|   438k|  int64_t f0f7_2  = f0_2 * (int64_t) f7;
  837|   438k|  int64_t f0f8_2  = f0_2 * (int64_t) f8;
  838|   438k|  int64_t f0f9_2  = f0_2 * (int64_t) f9;
  839|   438k|  int64_t f1f1_2  = f1_2 * (int64_t) f1;
  840|   438k|  int64_t f1f2_2  = f1_2 * (int64_t) f2;
  841|   438k|  int64_t f1f3_4  = f1_2 * (int64_t) f3_2;
  842|   438k|  int64_t f1f4_2  = f1_2 * (int64_t) f4;
  843|   438k|  int64_t f1f5_4  = f1_2 * (int64_t) f5_2;
  844|   438k|  int64_t f1f6_2  = f1_2 * (int64_t) f6;
  845|   438k|  int64_t f1f7_4  = f1_2 * (int64_t) f7_2;
  846|   438k|  int64_t f1f8_2  = f1_2 * (int64_t) f8;
  847|   438k|  int64_t f1f9_76 = f1_2 * (int64_t) f9_38;
  848|   438k|  int64_t f2f2    = f2   * (int64_t) f2;
  849|   438k|  int64_t f2f3_2  = f2_2 * (int64_t) f3;
  850|   438k|  int64_t f2f4_2  = f2_2 * (int64_t) f4;
  851|   438k|  int64_t f2f5_2  = f2_2 * (int64_t) f5;
  852|   438k|  int64_t f2f6_2  = f2_2 * (int64_t) f6;
  853|   438k|  int64_t f2f7_2  = f2_2 * (int64_t) f7;
  854|   438k|  int64_t f2f8_38 = f2_2 * (int64_t) f8_19;
  855|   438k|  int64_t f2f9_38 = f2   * (int64_t) f9_38;
  856|   438k|  int64_t f3f3_2  = f3_2 * (int64_t) f3;
  857|   438k|  int64_t f3f4_2  = f3_2 * (int64_t) f4;
  858|   438k|  int64_t f3f5_4  = f3_2 * (int64_t) f5_2;
  859|   438k|  int64_t f3f6_2  = f3_2 * (int64_t) f6;
  860|   438k|  int64_t f3f7_76 = f3_2 * (int64_t) f7_38;
  861|   438k|  int64_t f3f8_38 = f3_2 * (int64_t) f8_19;
  862|   438k|  int64_t f3f9_76 = f3_2 * (int64_t) f9_38;
  863|   438k|  int64_t f4f4    = f4   * (int64_t) f4;
  864|   438k|  int64_t f4f5_2  = f4_2 * (int64_t) f5;
  865|   438k|  int64_t f4f6_38 = f4_2 * (int64_t) f6_19;
  866|   438k|  int64_t f4f7_38 = f4   * (int64_t) f7_38;
  867|   438k|  int64_t f4f8_38 = f4_2 * (int64_t) f8_19;
  868|   438k|  int64_t f4f9_38 = f4   * (int64_t) f9_38;
  869|   438k|  int64_t f5f5_38 = f5   * (int64_t) f5_38;
  870|   438k|  int64_t f5f6_38 = f5_2 * (int64_t) f6_19;
  871|   438k|  int64_t f5f7_76 = f5_2 * (int64_t) f7_38;
  872|   438k|  int64_t f5f8_38 = f5_2 * (int64_t) f8_19;
  873|   438k|  int64_t f5f9_76 = f5_2 * (int64_t) f9_38;
  874|   438k|  int64_t f6f6_19 = f6   * (int64_t) f6_19;
  875|   438k|  int64_t f6f7_38 = f6   * (int64_t) f7_38;
  876|   438k|  int64_t f6f8_38 = f6_2 * (int64_t) f8_19;
  877|   438k|  int64_t f6f9_38 = f6   * (int64_t) f9_38;
  878|   438k|  int64_t f7f7_38 = f7   * (int64_t) f7_38;
  879|   438k|  int64_t f7f8_38 = f7_2 * (int64_t) f8_19;
  880|   438k|  int64_t f7f9_76 = f7_2 * (int64_t) f9_38;
  881|   438k|  int64_t f8f8_19 = f8   * (int64_t) f8_19;
  882|   438k|  int64_t f8f9_38 = f8   * (int64_t) f9_38;
  883|   438k|  int64_t f9f9_38 = f9   * (int64_t) f9_38;
  884|   438k|  int64_t h0 = f0f0  +f1f9_76+f2f8_38+f3f7_76+f4f6_38+f5f5_38;
  885|   438k|  int64_t h1 = f0f1_2+f2f9_38+f3f8_38+f4f7_38+f5f6_38;
  886|   438k|  int64_t h2 = f0f2_2+f1f1_2 +f3f9_76+f4f8_38+f5f7_76+f6f6_19;
  887|   438k|  int64_t h3 = f0f3_2+f1f2_2 +f4f9_38+f5f8_38+f6f7_38;
  888|   438k|  int64_t h4 = f0f4_2+f1f3_4 +f2f2   +f5f9_76+f6f8_38+f7f7_38;
  889|   438k|  int64_t h5 = f0f5_2+f1f4_2 +f2f3_2 +f6f9_38+f7f8_38;
  890|   438k|  int64_t h6 = f0f6_2+f1f5_4 +f2f4_2 +f3f3_2 +f7f9_76+f8f8_19;
  891|   438k|  int64_t h7 = f0f7_2+f1f6_2 +f2f5_2 +f3f4_2 +f8f9_38;
  892|   438k|  int64_t h8 = f0f8_2+f1f7_4 +f2f6_2 +f3f5_4 +f4f4   +f9f9_38;
  893|   438k|  int64_t h9 = f0f9_2+f1f8_2 +f2f7_2 +f3f6_2 +f4f5_2;
  894|   438k|  int64_t carry0;
  895|   438k|  int64_t carry1;
  896|   438k|  int64_t carry2;
  897|   438k|  int64_t carry3;
  898|   438k|  int64_t carry4;
  899|   438k|  int64_t carry5;
  900|   438k|  int64_t carry6;
  901|   438k|  int64_t carry7;
  902|   438k|  int64_t carry8;
  903|   438k|  int64_t carry9;
  904|       |
  905|   438k|  h0 += h0;
  906|   438k|  h1 += h1;
  907|   438k|  h2 += h2;
  908|   438k|  h3 += h3;
  909|   438k|  h4 += h4;
  910|   438k|  h5 += h5;
  911|   438k|  h6 += h6;
  912|   438k|  h7 += h7;
  913|   438k|  h8 += h8;
  914|   438k|  h9 += h9;
  915|       |
  916|   438k|  carry0 = (h0 + (int64_t) (1<<25)) >> 26; h1 += carry0; h0 -= carry0 << 26;
  917|   438k|  carry4 = (h4 + (int64_t) (1<<25)) >> 26; h5 += carry4; h4 -= carry4 << 26;
  918|       |
  919|   438k|  carry1 = (h1 + (int64_t) (1<<24)) >> 25; h2 += carry1; h1 -= carry1 << 25;
  920|   438k|  carry5 = (h5 + (int64_t) (1<<24)) >> 25; h6 += carry5; h5 -= carry5 << 25;
  921|       |
  922|   438k|  carry2 = (h2 + (int64_t) (1<<25)) >> 26; h3 += carry2; h2 -= carry2 << 26;
  923|   438k|  carry6 = (h6 + (int64_t) (1<<25)) >> 26; h7 += carry6; h6 -= carry6 << 26;
  924|       |
  925|   438k|  carry3 = (h3 + (int64_t) (1<<24)) >> 25; h4 += carry3; h3 -= carry3 << 25;
  926|   438k|  carry7 = (h7 + (int64_t) (1<<24)) >> 25; h8 += carry7; h7 -= carry7 << 25;
  927|       |
  928|   438k|  carry4 = (h4 + (int64_t) (1<<25)) >> 26; h5 += carry4; h4 -= carry4 << 26;
  929|   438k|  carry8 = (h8 + (int64_t) (1<<25)) >> 26; h9 += carry8; h8 -= carry8 << 26;
  930|       |
  931|   438k|  carry9 = (h9 + (int64_t) (1<<24)) >> 25; h0 += carry9 * 19; h9 -= carry9 << 25;
  932|       |
  933|   438k|  carry0 = (h0 + (int64_t) (1<<25)) >> 26; h1 += carry0; h0 -= carry0 << 26;
  934|       |
  935|   438k|  h[0] = h0;
  936|   438k|  h[1] = h1;
  937|   438k|  h[2] = h2;
  938|   438k|  h[3] = h3;
  939|   438k|  h[4] = h4;
  940|   438k|  h[5] = h5;
  941|   438k|  h[6] = h6;
  942|   438k|  h[7] = h7;
  943|   438k|  h[8] = h8;
  944|   438k|  h[9] = h9;
  945|   438k|}
crypto-ops.c:ge_p3_dbl:
 1532|   109k|static void ge_p3_dbl(ge_p1p1 *r, const ge_p3 *p) {
 1533|   109k|  ge_p2 q;
 1534|   109k|  ge_p3_to_p2(&q, p);
 1535|   109k|  ge_p2_dbl(r, &q);
 1536|   109k|}
crypto-ops.c:fe_copy:
  233|  14.3M|static void fe_copy(fe h, const fe f) {
  234|  14.3M|  int32_t f0 = f[0];
  235|  14.3M|  int32_t f1 = f[1];
  236|  14.3M|  int32_t f2 = f[2];
  237|  14.3M|  int32_t f3 = f[3];
  238|  14.3M|  int32_t f4 = f[4];
  239|  14.3M|  int32_t f5 = f[5];
  240|  14.3M|  int32_t f6 = f[6];
  241|  14.3M|  int32_t f7 = f[7];
  242|  14.3M|  int32_t f8 = f[8];
  243|  14.3M|  int32_t f9 = f[9];
  244|  14.3M|  h[0] = f0;
  245|  14.3M|  h[1] = f1;
  246|  14.3M|  h[2] = f2;
  247|  14.3M|  h[3] = f3;
  248|  14.3M|  h[4] = f4;
  249|  14.3M|  h[5] = f5;
  250|  14.3M|  h[6] = f6;
  251|  14.3M|  h[7] = f7;
  252|  14.3M|  h[8] = f8;
  253|  14.3M|  h[9] = f9;
  254|  14.3M|}
crypto-ops.c:ge_p3_0:
 1519|   109k|static void ge_p3_0(ge_p3 *h) {
 1520|   109k|  fe_0(h->X);
 1521|   109k|  fe_1(h->Y);
 1522|   109k|  fe_1(h->Z);
 1523|   109k|  fe_0(h->T);
 1524|   109k|}
crypto-ops.c:select:
 1609|  7.01M|static void select(ge_precomp *t, int pos, signed char b) {
 1610|  7.01M|  ge_precomp minust;
 1611|  7.01M|  unsigned char bnegative = negative(b);
 1612|  7.01M|  unsigned char babs = b - (((-bnegative) & b) << 1);
 1613|       |
 1614|  7.01M|  ge_precomp_0(t);
 1615|  7.01M|  ge_precomp_cmov(t, &ge_base[pos][0], equal(babs, 1));
 1616|  7.01M|  ge_precomp_cmov(t, &ge_base[pos][1], equal(babs, 2));
 1617|  7.01M|  ge_precomp_cmov(t, &ge_base[pos][2], equal(babs, 3));
 1618|  7.01M|  ge_precomp_cmov(t, &ge_base[pos][3], equal(babs, 4));
 1619|  7.01M|  ge_precomp_cmov(t, &ge_base[pos][4], equal(babs, 5));
 1620|  7.01M|  ge_precomp_cmov(t, &ge_base[pos][5], equal(babs, 6));
 1621|  7.01M|  ge_precomp_cmov(t, &ge_base[pos][6], equal(babs, 7));
 1622|  7.01M|  ge_precomp_cmov(t, &ge_base[pos][7], equal(babs, 8));
 1623|  7.01M|  fe_copy(minust.yplusx, t->yminusx);
 1624|  7.01M|  fe_copy(minust.yminusx, t->yplusx);
 1625|  7.01M|  fe_neg(minust.xy2d, t->xy2d);
 1626|  7.01M|  ge_precomp_cmov(t, &minust, bnegative);
 1627|  7.01M|}
crypto-ops.c:ge_precomp_0:
 1579|  7.01M|static void ge_precomp_0(ge_precomp *h) {
 1580|  7.01M|  fe_1(h->yplusx);
 1581|  7.01M|  fe_1(h->yminusx);
 1582|  7.01M|  fe_0(h->xy2d);
 1583|  7.01M|}
crypto-ops.c:ge_precomp_cmov:
 1603|  63.1M|static void ge_precomp_cmov(ge_precomp *t, const ge_precomp *u, unsigned char b) {
 1604|  63.1M|  fe_cmov(t->yplusx, u->yplusx, b);
 1605|  63.1M|  fe_cmov(t->yminusx, u->yminusx, b);
 1606|  63.1M|  fe_cmov(t->xy2d, u->xy2d, b);
 1607|  63.1M|}
crypto-ops.c:fe_cmov:
  172|   189M|static void fe_cmov(fe f, const fe g, unsigned int b) {
  173|   189M|  int32_t f0 = f[0];
  174|   189M|  int32_t f1 = f[1];
  175|   189M|  int32_t f2 = f[2];
  176|   189M|  int32_t f3 = f[3];
  177|   189M|  int32_t f4 = f[4];
  178|   189M|  int32_t f5 = f[5];
  179|   189M|  int32_t f6 = f[6];
  180|   189M|  int32_t f7 = f[7];
  181|   189M|  int32_t f8 = f[8];
  182|   189M|  int32_t f9 = f[9];
  183|   189M|  int32_t g0 = g[0];
  184|   189M|  int32_t g1 = g[1];
  185|   189M|  int32_t g2 = g[2];
  186|   189M|  int32_t g3 = g[3];
  187|   189M|  int32_t g4 = g[4];
  188|   189M|  int32_t g5 = g[5];
  189|   189M|  int32_t g6 = g[6];
  190|   189M|  int32_t g7 = g[7];
  191|   189M|  int32_t g8 = g[8];
  192|   189M|  int32_t g9 = g[9];
  193|   189M|  int32_t x0 = f0 ^ g0;
  194|   189M|  int32_t x1 = f1 ^ g1;
  195|   189M|  int32_t x2 = f2 ^ g2;
  196|   189M|  int32_t x3 = f3 ^ g3;
  197|   189M|  int32_t x4 = f4 ^ g4;
  198|   189M|  int32_t x5 = f5 ^ g5;
  199|   189M|  int32_t x6 = f6 ^ g6;
  200|   189M|  int32_t x7 = f7 ^ g7;
  201|   189M|  int32_t x8 = f8 ^ g8;
  202|   189M|  int32_t x9 = f9 ^ g9;
  203|   189M|  assert((((b - 1) & ~b) | ((b - 2) & ~(b - 1))) == (unsigned int) -1);
  204|   189M|  b = -b;
  205|   189M|  x0 &= b;
  206|   189M|  x1 &= b;
  207|   189M|  x2 &= b;
  208|   189M|  x3 &= b;
  209|   189M|  x4 &= b;
  210|   189M|  x5 &= b;
  211|   189M|  x6 &= b;
  212|   189M|  x7 &= b;
  213|   189M|  x8 &= b;
  214|   189M|  x9 &= b;
  215|   189M|  f[0] = f0 ^ x0;
  216|   189M|  f[1] = f1 ^ x1;
  217|   189M|  f[2] = f2 ^ x2;
  218|   189M|  f[3] = f3 ^ x3;
  219|   189M|  f[4] = f4 ^ x4;
  220|   189M|  f[5] = f5 ^ x5;
  221|   189M|  f[6] = f6 ^ x6;
  222|   189M|  f[7] = f7 ^ x7;
  223|   189M|  f[8] = f8 ^ x8;
  224|   189M|  f[9] = f9 ^ x9;
  225|   189M|}
crypto-ops.c:fe_divpowm1:
 1958|    553|static void fe_divpowm1(fe r, const fe u, const fe v) {
 1959|    553|  fe v3, uv7, t0, t1, t2;
 1960|    553|  int i;
 1961|       |
 1962|    553|  fe_sq(v3, v);
 1963|    553|  fe_mul(v3, v3, v); /* v3 = v^3 */
 1964|    553|  fe_sq(uv7, v3);
 1965|    553|  fe_mul(uv7, uv7, v);
 1966|    553|  fe_mul(uv7, uv7, u); /* uv7 = uv^7 */
 1967|       |
 1968|       |  /*fe_pow22523(uv7, uv7);*/
 1969|       |
 1970|       |  /* From fe_pow22523.c */
 1971|       |
 1972|    553|  fe_sq(t0, uv7);
 1973|    553|  fe_sq(t1, t0);
 1974|    553|  fe_sq(t1, t1);
 1975|    553|  fe_mul(t1, uv7, t1);
 1976|    553|  fe_mul(t0, t0, t1);
 1977|    553|  fe_sq(t0, t0);
 1978|    553|  fe_mul(t0, t1, t0);
 1979|    553|  fe_sq(t1, t0);
 1980|  2.76k|  for (i = 0; i < 4; ++i) {
  ------------------
  |  Branch (1980:15): [True: 2.21k, False: 553]
  ------------------
 1981|  2.21k|    fe_sq(t1, t1);
 1982|  2.21k|  }
 1983|    553|  fe_mul(t0, t1, t0);
 1984|    553|  fe_sq(t1, t0);
 1985|  5.53k|  for (i = 0; i < 9; ++i) {
  ------------------
  |  Branch (1985:15): [True: 4.97k, False: 553]
  ------------------
 1986|  4.97k|    fe_sq(t1, t1);
 1987|  4.97k|  }
 1988|    553|  fe_mul(t1, t1, t0);
 1989|    553|  fe_sq(t2, t1);
 1990|  11.0k|  for (i = 0; i < 19; ++i) {
  ------------------
  |  Branch (1990:15): [True: 10.5k, False: 553]
  ------------------
 1991|  10.5k|    fe_sq(t2, t2);
 1992|  10.5k|  }
 1993|    553|  fe_mul(t1, t2, t1);
 1994|  6.08k|  for (i = 0; i < 10; ++i) {
  ------------------
  |  Branch (1994:15): [True: 5.53k, False: 553]
  ------------------
 1995|  5.53k|    fe_sq(t1, t1);
 1996|  5.53k|  }
 1997|    553|  fe_mul(t0, t1, t0);
 1998|    553|  fe_sq(t1, t0);
 1999|  27.6k|  for (i = 0; i < 49; ++i) {
  ------------------
  |  Branch (1999:15): [True: 27.0k, False: 553]
  ------------------
 2000|  27.0k|    fe_sq(t1, t1);
 2001|  27.0k|  }
 2002|    553|  fe_mul(t1, t1, t0);
 2003|    553|  fe_sq(t2, t1);
 2004|  55.3k|  for (i = 0; i < 99; ++i) {
  ------------------
  |  Branch (2004:15): [True: 54.7k, False: 553]
  ------------------
 2005|  54.7k|    fe_sq(t2, t2);
 2006|  54.7k|  }
 2007|    553|  fe_mul(t1, t2, t1);
 2008|  28.2k|  for (i = 0; i < 50; ++i) {
  ------------------
  |  Branch (2008:15): [True: 27.6k, False: 553]
  ------------------
 2009|  27.6k|    fe_sq(t1, t1);
 2010|  27.6k|  }
 2011|    553|  fe_mul(t0, t1, t0);
 2012|    553|  fe_sq(t0, t0);
 2013|    553|  fe_sq(t0, t0);
 2014|    553|  fe_mul(t0, t0, uv7);
 2015|       |
 2016|       |  /* End fe_pow22523.c */
 2017|       |  /* t0 = (uv^7)^((q-5)/8) */
 2018|    553|  fe_mul(t0, t0, v3);
 2019|    553|  fe_mul(r, t0, u); /* u^(m+1)v^(-(m+1)) */
 2020|    553|}
crypto-ops.c:negative:
 1597|  7.01M|static unsigned char negative(signed char b) {
 1598|  7.01M|  unsigned long long x = b; /* 18446744073709551361..18446744073709551615: yes; 0..255: no */
 1599|  7.01M|  x >>= 63; /* 1: yes; 0: no */
 1600|  7.01M|  return x;
 1601|  7.01M|}
crypto-ops.c:equal:
 1587|  56.1M|static unsigned char equal(signed char b, signed char c) {
 1588|  56.1M|  unsigned char ub = b;
 1589|  56.1M|  unsigned char uc = c;
 1590|  56.1M|  unsigned char x = ub ^ uc; /* 0: yes; 1..255: no */
 1591|  56.1M|  uint32_t y = x; /* 0: yes; 1..255: no */
 1592|  56.1M|  y -= 1; /* 4294967295: yes; 0..254: no */
 1593|  56.1M|  y >>= 31; /* 1: yes; 0: no */
 1594|  56.1M|  return y;
 1595|  56.1M|}
crypto-ops.c:signum:
 3809|  46.9k|static int64_t signum(int64_t a) {
 3810|  46.9k|  return a > 0 ? 1 : a < 0 ? -1 : 0;
  ------------------
  |  Branch (3810:10): [True: 17.4k, False: 29.5k]
  |  Branch (3810:22): [True: 29.5k, False: 0]
  ------------------
 3811|  46.9k|}

_ZN6crypto15get_random_lockEv:
   94|   116k|  {
   95|   116k|    static boost::mutex random_lock;
   96|   116k|    return random_lock;
   97|   116k|  }
_ZN6crypto33generate_random_bytes_thread_safeEmPh:
  100|   116k|  {
  101|   116k|    boost::lock_guard<boost::mutex> lock(get_random_lock());
  102|   116k|    generate_random_bytes_not_thread_safe(N, bytes);
  103|   116k|  }
_ZN6crypto17random32_unbiasedEPh:
  124|   103k|  {
  125|       |    // l = 2^252 + 27742317777372353535851937790883648493.
  126|       |    // l fits 15 times in 32 bytes (iow, 15 l is the highest multiple of l that fits in 32 bytes)
  127|   103k|    static const unsigned char limit[32] = { 0xe3, 0x6a, 0x67, 0x72, 0x8b, 0xce, 0x13, 0x29, 0x8f, 0x30, 0x82, 0x8c, 0x0b, 0xa4, 0x10, 0x39, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0 };
  128|   110k|    while(1)
  ------------------
  |  Branch (128:11): [Folded - Ignored]
  ------------------
  129|   110k|    {
  130|   110k|      generate_random_bytes_thread_safe(32, bytes);
  131|   110k|      if (!less32(bytes, limit))
  ------------------
  |  Branch (131:11): [True: 6.93k, False: 103k]
  ------------------
  132|  6.93k|        continue;
  133|   103k|      sc_reduce32(bytes);
  134|   103k|      if (sc_isnonzero(bytes))
  ------------------
  |  Branch (134:11): [True: 103k, False: 0]
  ------------------
  135|   103k|        break;
  136|   103k|    }
  137|   103k|  }
_ZN6crypto14hash_to_scalarEPKvmRNS_9ec_scalarE:
  143|  15.8k|  void hash_to_scalar(const void *data, size_t length, ec_scalar &res) {
  144|  15.8k|    cn_fast_hash(data, length, reinterpret_cast<hash &>(res));
  145|  15.8k|    sc_reduce32(&res);
  146|  15.8k|  }
_ZN6crypto10crypto_ops13generate_keysERNS_10public_keyERN4epee7mlockedIN5tools8scrubbedINS_9ec_scalarEEEEERKS9_b:
  153|  98.2k|  secret_key crypto_ops::generate_keys(public_key &pub, secret_key &sec, const secret_key& recovery_key, bool recover) {
  154|  98.2k|    ge_p3 point;
  155|       |
  156|  98.2k|    secret_key rng;
  157|       |
  158|  98.2k|    if (recover)
  ------------------
  |  Branch (158:9): [True: 2, False: 98.2k]
  ------------------
  159|      2|    {
  160|      2|      rng = recovery_key;
  161|      2|    }
  162|  98.2k|    else
  163|  98.2k|    {
  164|  98.2k|      random_scalar(rng);
  165|  98.2k|    }
  166|  98.2k|    sec = rng;
  167|  98.2k|    sc_reduce32(&unwrap(sec));  // reduce in case second round of keys (sendkeys)
  168|       |
  169|  98.2k|    ge_scalarmult_base(&point, &unwrap(sec));
  170|  98.2k|    ge_p3_tobytes(&pub, &point);
  171|       |
  172|  98.2k|    return rng;
  173|  98.2k|  }
_ZN6crypto10crypto_ops24secret_key_to_public_keyERKN4epee7mlockedIN5tools8scrubbedINS_9ec_scalarEEEEERNS_10public_keyE:
  180|  5.87k|  bool crypto_ops::secret_key_to_public_key(const secret_key &sec, public_key &pub) {
  181|  5.87k|    ge_p3 point;
  182|  5.87k|    if (sc_check(&unwrap(sec)) != 0) {
  ------------------
  |  Branch (182:9): [True: 0, False: 5.87k]
  ------------------
  183|      0|      return false;
  184|      0|    }
  185|  5.87k|    ge_scalarmult_base(&point, &unwrap(sec));
  186|  5.87k|    ge_p3_tobytes(&pub, &point);
  187|  5.87k|    return true;
  188|  5.87k|  }
_ZN6crypto10crypto_ops20derivation_to_scalarERKNS_14key_derivationEmRNS_9ec_scalarE:
  205|  9.97k|  void crypto_ops::derivation_to_scalar(const key_derivation &derivation, size_t output_index, ec_scalar &res) {
  206|  9.97k|    struct {
  207|  9.97k|      key_derivation derivation;
  208|  9.97k|      char output_index[(sizeof(size_t) * 8 + 6) / 7];
  209|  9.97k|    } buf;
  210|  9.97k|    char *end = buf.output_index;
  211|  9.97k|    buf.derivation = derivation;
  212|  9.97k|    tools::write_varint(end, output_index);
  213|  9.97k|    assert(end <= buf.output_index + sizeof buf.output_index);
  214|  9.97k|    hash_to_scalar(&buf, end - reinterpret_cast<char *>(&buf), res);
  215|  9.97k|  }
_ZN6crypto10crypto_ops17derive_secret_keyERKNS_14key_derivationEmRKN4epee7mlockedIN5tools8scrubbedINS_9ec_scalarEEEEERSA_:
  238|      1|    const secret_key &base, secret_key &derived_key) {
  239|      1|    ec_scalar scalar;
  240|      1|    assert(sc_check(&base) == 0);
  241|      1|    derivation_to_scalar(derivation, output_index, scalar);
  242|      1|    sc_add(&unwrap(derived_key), &unwrap(base), &scalar);
  243|      1|  }
_ZN6crypto10crypto_ops18generate_signatureERKNS_4hashERKNS_10public_keyERKN4epee7mlockedIN5tools8scrubbedINS_9ec_scalarEEEEERNS_9signatureE:
  290|  5.59k|  void crypto_ops::generate_signature(const hash &prefix_hash, const public_key &pub, const secret_key &sec, signature &sig) {
  291|  5.59k|    ge_p3 tmp3;
  292|  5.59k|    ec_scalar k;
  293|  5.59k|    s_comm buf;
  294|       |#if !defined(NDEBUG)
  295|       |    {
  296|       |      ge_p3 t;
  297|       |      public_key t2;
  298|       |      assert(sc_check(&sec) == 0);
  299|       |      ge_scalarmult_base(&t, &sec);
  300|       |      ge_p3_tobytes(&t2, &t);
  301|       |      assert(pub == t2);
  302|       |    }
  303|       |#endif
  304|  5.59k|    buf.h = prefix_hash;
  305|  5.59k|    buf.key = pub;
  306|  5.59k|  try_again:
  307|  5.59k|    random_scalar(k);
  308|  5.59k|    ge_scalarmult_base(&tmp3, &k);
  309|  5.59k|    ge_p3_tobytes(&buf.comm, &tmp3);
  310|  5.59k|    hash_to_scalar(&buf, sizeof(s_comm), sig.c);
  311|  5.59k|    if (!sc_isnonzero((const unsigned char*)sig.c.data))
  ------------------
  |  Branch (311:9): [True: 0, False: 5.59k]
  ------------------
  312|      0|      goto try_again;
  313|  5.59k|    sc_mulsub(&sig.r, &sig.c, &unwrap(sec), &k);
  314|  5.59k|    if (!sc_isnonzero((const unsigned char*)sig.r.data))
  ------------------
  |  Branch (314:9): [True: 0, False: 5.59k]
  ------------------
  315|      0|      goto try_again;
  316|  5.59k|    memwipe(&k, sizeof(k));
  317|  5.59k|  }
_ZN6crypto10crypto_ops15derive_view_tagERKNS_14key_derivationEmRNS_8view_tagE:
  753|  1.08k|  void crypto_ops::derive_view_tag(const key_derivation &derivation, size_t output_index, view_tag &view_tag) {
  754|  1.08k|    #pragma pack(push, 1)
  755|  1.08k|    struct {
  756|  1.08k|      char salt[8]; // view tag domain-separator
  757|  1.08k|      key_derivation derivation;
  758|  1.08k|      char output_index[(sizeof(size_t) * 8 + 6) / 7];
  759|  1.08k|    } buf;
  760|  1.08k|    #pragma pack(pop)
  761|       |
  762|  1.08k|    char *end = buf.output_index;
  763|  1.08k|    memcpy(buf.salt, "view_tag", 8); // leave off null terminator
  764|  1.08k|    buf.derivation = derivation;
  765|  1.08k|    tools::write_varint(end, output_index);
  766|  1.08k|    assert(end <= buf.output_index + sizeof buf.output_index);
  767|       |
  768|       |    // view_tag_full = H[salt|derivation|output_index]
  769|  1.08k|    hash view_tag_full;
  770|  1.08k|    cn_fast_hash(&buf, end - reinterpret_cast<char *>(&buf), view_tag_full);
  771|       |
  772|       |    // only need a slice of view_tag_full to realize optimal perf/space efficiency
  773|  1.08k|    static_assert(sizeof(crypto::view_tag) <= sizeof(view_tag_full), "view tag should not be larger than hash result");
  774|  1.08k|    memcpy(&view_tag, &view_tag_full, sizeof(crypto::view_tag));
  775|  1.08k|  }
crypto.cpp:_ZN6cryptoL6less32EPKhS1_:
  112|   110k|  {
  113|   111k|    for (int n = 31; n >= 0; --n)
  ------------------
  |  Branch (113:22): [True: 111k, False: 0]
  ------------------
  114|   111k|    {
  115|   111k|      if (k0[n] < k1[n])
  ------------------
  |  Branch (115:11): [True: 103k, False: 7.38k]
  ------------------
  116|   103k|        return true;
  117|  7.38k|      if (k0[n] > k1[n])
  ------------------
  |  Branch (117:11): [True: 6.93k, False: 451]
  ------------------
  118|  6.93k|        return false;
  119|  7.38k|    }
  120|      0|    return false;
  121|   110k|  }
crypto.cpp:_ZN6cryptoadERNS_9ec_scalarE:
   85|   240k|  static inline unsigned char *operator &(ec_scalar &scalar) {
   86|   240k|    return &reinterpret_cast<unsigned char &>(scalar);
   87|   240k|  }
crypto.cpp:_ZN6cryptoL13random_scalarERNS_9ec_scalarE:
  139|   103k|  static inline void random_scalar(ec_scalar &res) {
  140|   103k|    random32_unbiased((unsigned char*)res.data);
  141|   103k|  }
crypto.cpp:_ZN6cryptoadERNS_8ec_pointE:
   77|   109k|  static inline unsigned char *operator &(ec_point &point) {
   78|   109k|    return &reinterpret_cast<unsigned char &>(point);
   79|   109k|  }
crypto.cpp:_ZN6cryptoadERKNS_9ec_scalarE:
   89|  17.3k|  static inline const unsigned char *operator &(const ec_scalar &scalar) {
   90|  17.3k|    return &reinterpret_cast<const unsigned char &>(scalar);
   91|  17.3k|  }

_ZN6crypto13generate_keysERNS_10public_keyERN4epee7mlockedIN5tools8scrubbedINS_9ec_scalarEEEEERKS8_b:
  194|  98.2k|  inline secret_key generate_keys(public_key &pub, secret_key &sec, const secret_key& recovery_key = secret_key(), bool recover = false) {
  195|  98.2k|    return crypto_ops::generate_keys(pub, sec, recovery_key, recover);
  196|  98.2k|  }
_ZN6crypto24secret_key_to_public_keyERKN4epee7mlockedIN5tools8scrubbedINS_9ec_scalarEEEEERNS_10public_keyE:
  206|  5.87k|  inline bool secret_key_to_public_key(const secret_key &sec, public_key &pub) {
  207|  5.87k|    return crypto_ops::secret_key_to_public_key(sec, pub);
  208|  5.87k|  }
_ZN6crypto20derivation_to_scalarERKNS_14key_derivationEmRNS_9ec_scalarE:
  223|  9.97k|  inline void derivation_to_scalar(const key_derivation &derivation, size_t output_index, ec_scalar &res) {
  224|  9.97k|    return crypto_ops::derivation_to_scalar(derivation, output_index, res);
  225|  9.97k|  }
_ZN6crypto17derive_secret_keyERKNS_14key_derivationEmRKN4epee7mlockedIN5tools8scrubbedINS_9ec_scalarEEEEERS9_:
  227|      1|    const secret_key &base, secret_key &derived_key) {
  228|      1|    crypto_ops::derive_secret_key(derivation, output_index, base, derived_key);
  229|      1|  }
_ZN6crypto18generate_signatureERKNS_4hashERKNS_10public_keyERKN4epee7mlockedIN5tools8scrubbedINS_9ec_scalarEEEEERNS_9signatureE:
  236|  5.59k|  inline void generate_signature(const hash &prefix_hash, const public_key &pub, const secret_key &sec, signature &sig) {
  237|  5.59k|    crypto_ops::generate_signature(prefix_hash, pub, sec, sig);
  238|  5.59k|  }
_ZN6crypto15derive_view_tagERKNS_14key_derivationEmRNS_8view_tagE:
  296|  1.08k|  inline void derive_view_tag(const key_derivation &derivation, std::size_t output_index, view_tag &vt) {
  297|  1.08k|    crypto_ops::derive_view_tag(derivation, output_index, vt);
  298|  1.08k|  }
_ZN6crypto4randINS_9chacha_ivEEET_v:
  158|  5.59k|  T rand() {
  159|  5.59k|    static_assert(std::is_standard_layout_v<T>, "cannot write random bytes into non-standard layout type");
  160|  5.59k|    static_assert(std::is_trivially_copyable_v<T>, "cannot write random bytes into non-trivially copyable type");
  161|  5.59k|    typename std::remove_cv<T>::type res;
  162|  5.59k|    generate_random_bytes_thread_safe(sizeof(T), (uint8_t*)&res);
  163|  5.59k|    return res;
  164|  5.59k|  }

_ZN6cryptoeqERKNS_4hashES2_:
   41|    197|  inline bool operator==(const type &_v1, const type &_v2) { \
   42|    197|    return !memcmp(&_v1, &_v2, sizeof(_v1)); \
   43|    197|  } \
_ZN6cryptoeqERKNS_10public_keyES2_:
   41|  32.4M|  inline bool operator==(const type &_v1, const type &_v2) { \
   42|  32.4M|    return !memcmp(&_v1, &_v2, sizeof(_v1)); \
   43|  32.4M|  } \
_ZNKSt3__14hashIN6crypto10public_keyEEclERKS2_:
   72|   282k|    std::size_t operator()(const crypto::type &_v) const { \
   73|   282k|      std::size_t h; \
   74|   282k|      memcpy(&h, std::addressof(_v), sizeof(h)); \
   75|   282k|      return h; \
   76|   282k|    } \
_ZN6cryptoeqERKN4epee7mlockedIN5tools8scrubbedINS_9ec_scalarEEEEES8_:
   51|      1|  inline bool operator==(const type &_v1, const type &_v2) { \
   52|      1|    static_assert(sizeof(_v1) == 32, "constant time comparison is only implenmted for 32 bytes"); \
   53|      1|    return crypto_verify_32((const unsigned char*)&_v1, (const unsigned char*)&_v2) == 0; \
   54|      1|  } \
_ZN6cryptoeqERKNS_9key_imageES2_:
   41|     58|  inline bool operator==(const type &_v1, const type &_v2) { \
   42|     58|    return !memcmp(&_v1, &_v2, sizeof(_v1)); \
   43|     58|  } \
_ZN6cryptoeqERKNS_8view_tagES2_:
   41|  1.08k|  inline bool operator==(const type &_v1, const type &_v2) { \
   42|  1.08k|    return !memcmp(&_v1, &_v2, sizeof(_v1)); \
   43|  1.08k|  } \

groestl:
  344|  5.60k|		BitSequence* hashval) {
  345|       |
  346|  5.60k|  hashState context;
  347|       |
  348|       |  /* initialise */
  349|  5.60k|    Init(&context);
  350|       |
  351|       |
  352|       |  /* process message */
  353|  5.60k|  Update(&context, data, databitlen);
  354|       |
  355|       |  /* finalise */
  356|  5.60k|  Final(&context, hashval);
  357|  5.60k|}
groestl.c:Init:
  214|  5.60k|static void Init(hashState* ctx) {
  215|       |  /* allocate memory for state and data buffer */
  216|       |
  217|  95.2k|  for(size_t i = 0; i < (SIZE512/sizeof(uint32_t)); i++)
  ------------------
  |  |   48|  95.2k|#define SIZE512 (ROWS*COLS512)
  |  |  ------------------
  |  |  |  |   44|  95.2k|#define ROWS 8
  |  |  ------------------
  |  |               #define SIZE512 (ROWS*COLS512)
  |  |  ------------------
  |  |  |  |   46|  95.2k|#define COLS512 8
  |  |  ------------------
  ------------------
  |  Branch (217:21): [True: 89.6k, False: 5.60k]
  ------------------
  218|  89.6k|  {
  219|  89.6k|	ctx->chaining[i] = 0;
  220|  89.6k|  }
  221|       |
  222|       |  /* set initial value */
  223|  5.60k|  ctx->chaining[2*COLS512-1] = SWAP32LE(u32BIG((uint32_t)HASH_BIT_LEN));
  ------------------
  |  |   46|  5.60k|#define COLS512 8
  ------------------
                ctx->chaining[2*COLS512-1] = SWAP32LE(u32BIG((uint32_t)HASH_BIT_LEN));
  ------------------
  |  |  277|  5.60k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|  5.60k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
  224|       |
  225|       |  /* set other variables */
  226|  5.60k|  ctx->buf_ptr = 0;
  227|  5.60k|  ctx->block_counter1 = 0;
  228|  5.60k|  ctx->block_counter2 = 0;
  229|  5.60k|  ctx->bits_in_last_byte = 0;
  230|  5.60k|}
groestl.c:Update:
  235|  5.60k|		  DataLength databitlen) {
  236|  5.60k|  int index = 0;
  237|  5.60k|  int msglen = (int)(databitlen/8);
  238|  5.60k|  int rem = (int)(databitlen%8);
  239|       |
  240|       |  /* if the buffer contains data that has not yet been digested, first
  241|       |     add data to buffer until full */
  242|  5.60k|  if (ctx->buf_ptr) {
  ------------------
  |  Branch (242:7): [True: 0, False: 5.60k]
  ------------------
  243|      0|    while (ctx->buf_ptr < SIZE512 && index < msglen) {
  ------------------
  |  |   48|      0|#define SIZE512 (ROWS*COLS512)
  |  |  ------------------
  |  |  |  |   44|      0|#define ROWS 8
  |  |  ------------------
  |  |               #define SIZE512 (ROWS*COLS512)
  |  |  ------------------
  |  |  |  |   46|      0|#define COLS512 8
  |  |  ------------------
  ------------------
  |  Branch (243:12): [True: 0, False: 0]
  |  Branch (243:38): [True: 0, False: 0]
  ------------------
  244|      0|      ctx->buffer[(int)ctx->buf_ptr++] = input[index++];
  245|      0|    }
  246|      0|    if (ctx->buf_ptr < SIZE512) {
  ------------------
  |  |   48|      0|#define SIZE512 (ROWS*COLS512)
  |  |  ------------------
  |  |  |  |   44|      0|#define ROWS 8
  |  |  ------------------
  |  |               #define SIZE512 (ROWS*COLS512)
  |  |  ------------------
  |  |  |  |   46|      0|#define COLS512 8
  |  |  ------------------
  ------------------
  |  Branch (246:9): [True: 0, False: 0]
  ------------------
  247|       |      /* buffer still not full, return */
  248|      0|      if (rem) {
  ------------------
  |  Branch (248:11): [True: 0, False: 0]
  ------------------
  249|      0|	ctx->bits_in_last_byte = rem;
  250|      0|	ctx->buffer[(int)ctx->buf_ptr++] = input[index];
  251|      0|      }
  252|      0|      return;
  253|      0|    }
  254|       |
  255|       |    /* digest buffer */
  256|      0|    ctx->buf_ptr = 0;
  257|      0|    Transform(ctx, ctx->buffer, SIZE512);
  ------------------
  |  |   48|      0|#define SIZE512 (ROWS*COLS512)
  |  |  ------------------
  |  |  |  |   44|      0|#define ROWS 8
  |  |  ------------------
  |  |               #define SIZE512 (ROWS*COLS512)
  |  |  ------------------
  |  |  |  |   46|      0|#define COLS512 8
  |  |  ------------------
  ------------------
  258|      0|  }
  259|       |
  260|       |  /* digest bulk of message */
  261|  5.60k|  Transform(ctx, input+index, msglen-index);
  262|  5.60k|  index += ((msglen-index)/SIZE512)*SIZE512;
  ------------------
  |  |   48|  5.60k|#define SIZE512 (ROWS*COLS512)
  |  |  ------------------
  |  |  |  |   44|  5.60k|#define ROWS 8
  |  |  ------------------
  |  |               #define SIZE512 (ROWS*COLS512)
  |  |  ------------------
  |  |  |  |   46|  5.60k|#define COLS512 8
  |  |  ------------------
  ------------------
                index += ((msglen-index)/SIZE512)*SIZE512;
  ------------------
  |  |   48|  5.60k|#define SIZE512 (ROWS*COLS512)
  |  |  ------------------
  |  |  |  |   44|  5.60k|#define ROWS 8
  |  |  ------------------
  |  |               #define SIZE512 (ROWS*COLS512)
  |  |  ------------------
  |  |  |  |   46|  5.60k|#define COLS512 8
  |  |  ------------------
  ------------------
  263|       |
  264|       |  /* store remaining data in buffer */
  265|  50.4k|  while (index < msglen) {
  ------------------
  |  Branch (265:10): [True: 44.8k, False: 5.60k]
  ------------------
  266|  44.8k|    ctx->buffer[(int)ctx->buf_ptr++] = input[index++];
  267|  44.8k|  }
  268|       |
  269|       |  /* if non-integral number of bytes have been supplied, store
  270|       |     remaining bits in last byte, together with information about
  271|       |     number of bits */
  272|  5.60k|  if (rem) {
  ------------------
  |  Branch (272:7): [True: 0, False: 5.60k]
  ------------------
  273|      0|    ctx->bits_in_last_byte = rem;
  274|      0|    ctx->buffer[(int)ctx->buf_ptr++] = input[index];
  275|      0|  }
  276|  5.60k|}
groestl.c:Transform:
  173|  11.2k|	       int msglen) {
  174|       |
  175|       |  /* digest message, one block at a time */
  176|  33.6k|  for (; msglen >= SIZE512; 
  ------------------
  |  |   48|  33.6k|#define SIZE512 (ROWS*COLS512)
  |  |  ------------------
  |  |  |  |   44|  33.6k|#define ROWS 8
  |  |  ------------------
  |  |               #define SIZE512 (ROWS*COLS512)
  |  |  ------------------
  |  |  |  |   46|  33.6k|#define COLS512 8
  |  |  ------------------
  ------------------
  |  Branch (176:10): [True: 22.4k, False: 11.2k]
  ------------------
  177|  22.4k|       msglen -= SIZE512, input += SIZE512) {
  ------------------
  |  |   48|  22.4k|#define SIZE512 (ROWS*COLS512)
  |  |  ------------------
  |  |  |  |   44|  22.4k|#define ROWS 8
  |  |  ------------------
  |  |               #define SIZE512 (ROWS*COLS512)
  |  |  ------------------
  |  |  |  |   46|  22.4k|#define COLS512 8
  |  |  ------------------
  ------------------
                     msglen -= SIZE512, input += SIZE512) {
  ------------------
  |  |   48|  22.4k|#define SIZE512 (ROWS*COLS512)
  |  |  ------------------
  |  |  |  |   44|  22.4k|#define ROWS 8
  |  |  ------------------
  |  |               #define SIZE512 (ROWS*COLS512)
  |  |  ------------------
  |  |  |  |   46|  22.4k|#define COLS512 8
  |  |  ------------------
  ------------------
  178|  22.4k|    F512(ctx->chaining,(uint32_t*)input);
  179|       |
  180|       |    /* increment block counter */
  181|  22.4k|    ctx->block_counter1++;
  182|  22.4k|    if (ctx->block_counter1 == 0) ctx->block_counter2++;
  ------------------
  |  Branch (182:9): [True: 0, False: 22.4k]
  ------------------
  183|  22.4k|  }
  184|  11.2k|}
groestl.c:F512:
  127|  22.4k|static void F512(uint32_t *h, const uint32_t *m) {
  128|  22.4k|  int i;
  129|  22.4k|  uint32_t Ptmp[2*COLS512];
  130|  22.4k|  uint32_t Qtmp[2*COLS512];
  131|  22.4k|  uint32_t y[2*COLS512];
  132|  22.4k|  uint32_t z[2*COLS512];
  133|       |
  134|   380k|  for (i = 0; i < 2*COLS512; i++) {
  ------------------
  |  |   46|   380k|#define COLS512 8
  ------------------
  |  Branch (134:15): [True: 358k, False: 22.4k]
  ------------------
  135|   358k|    z[i] = m[i];
  136|   358k|    Ptmp[i] = h[i]^m[i];
  137|   358k|  }
  138|       |
  139|       |  /* compute Q(m) */
  140|  22.4k|  RND512Q((uint8_t*)z, y, SWAP32LE(0x00000000));
  ------------------
  |  |  277|  22.4k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|  22.4k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
  141|  22.4k|  RND512Q((uint8_t*)y, z, SWAP32LE(0x01000000));
  ------------------
  |  |  277|  22.4k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|  22.4k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
  142|  22.4k|  RND512Q((uint8_t*)z, y, SWAP32LE(0x02000000));
  ------------------
  |  |  277|  22.4k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|  22.4k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
  143|  22.4k|  RND512Q((uint8_t*)y, z, SWAP32LE(0x03000000));
  ------------------
  |  |  277|  22.4k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|  22.4k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
  144|  22.4k|  RND512Q((uint8_t*)z, y, SWAP32LE(0x04000000));
  ------------------
  |  |  277|  22.4k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|  22.4k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
  145|  22.4k|  RND512Q((uint8_t*)y, z, SWAP32LE(0x05000000));
  ------------------
  |  |  277|  22.4k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|  22.4k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
  146|  22.4k|  RND512Q((uint8_t*)z, y, SWAP32LE(0x06000000));
  ------------------
  |  |  277|  22.4k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|  22.4k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
  147|  22.4k|  RND512Q((uint8_t*)y, z, SWAP32LE(0x07000000));
  ------------------
  |  |  277|  22.4k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|  22.4k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
  148|  22.4k|  RND512Q((uint8_t*)z, y, SWAP32LE(0x08000000));
  ------------------
  |  |  277|  22.4k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|  22.4k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
  149|  22.4k|  RND512Q((uint8_t*)y, Qtmp, SWAP32LE(0x09000000));
  ------------------
  |  |  277|  22.4k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|  22.4k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
  150|       |
  151|       |  /* compute P(h+m) */
  152|  22.4k|  RND512P((uint8_t*)Ptmp, y, SWAP32LE(0x00000000));
  ------------------
  |  |  277|  22.4k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|  22.4k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
  153|  22.4k|  RND512P((uint8_t*)y, z, SWAP32LE(0x00000001));
  ------------------
  |  |  277|  22.4k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|  22.4k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
  154|  22.4k|  RND512P((uint8_t*)z, y, SWAP32LE(0x00000002));
  ------------------
  |  |  277|  22.4k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|  22.4k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
  155|  22.4k|  RND512P((uint8_t*)y, z, SWAP32LE(0x00000003));
  ------------------
  |  |  277|  22.4k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|  22.4k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
  156|  22.4k|  RND512P((uint8_t*)z, y, SWAP32LE(0x00000004));
  ------------------
  |  |  277|  22.4k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|  22.4k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
  157|  22.4k|  RND512P((uint8_t*)y, z, SWAP32LE(0x00000005));
  ------------------
  |  |  277|  22.4k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|  22.4k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
  158|  22.4k|  RND512P((uint8_t*)z, y, SWAP32LE(0x00000006));
  ------------------
  |  |  277|  22.4k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|  22.4k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
  159|  22.4k|  RND512P((uint8_t*)y, z, SWAP32LE(0x00000007));
  ------------------
  |  |  277|  22.4k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|  22.4k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
  160|  22.4k|  RND512P((uint8_t*)z, y, SWAP32LE(0x00000008));
  ------------------
  |  |  277|  22.4k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|  22.4k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
  161|  22.4k|  RND512P((uint8_t*)y, Ptmp, SWAP32LE(0x00000009));
  ------------------
  |  |  277|  22.4k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|  22.4k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
  162|       |
  163|       |  /* compute P(h+m) + Q(m) + h */
  164|   380k|  for (i = 0; i < 2*COLS512; i++) {
  ------------------
  |  |   46|   380k|#define COLS512 8
  ------------------
  |  Branch (164:15): [True: 358k, False: 22.4k]
  ------------------
  165|   358k|    h[i] ^= Ptmp[i]^Qtmp[i];
  166|   358k|  }
  167|  22.4k|}
groestl.c:RND512Q:
   96|   224k|static void RND512Q(uint8_t *x, uint32_t *y, uint32_t r) {
   97|   224k|  uint32_t temp_v1, temp_v2, temp_upper_value, temp_lower_value, temp;
   98|   224k|  uint32_t* x32 = (uint32_t*)x;
   99|   224k|  x32[ 0] = ~x32[ 0];
  100|   224k|  x32[ 1] ^= SWAP32LE(0xffffffff)^r;
  ------------------
  |  |  277|   224k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|   224k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
  101|   224k|  x32[ 2] = ~x32[ 2];
  102|   224k|  x32[ 3] ^= SWAP32LE(0xefffffff)^r;
  ------------------
  |  |  277|   224k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|   224k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
  103|   224k|  x32[ 4] = ~x32[ 4];
  104|   224k|  x32[ 5] ^= SWAP32LE(0xdfffffff)^r;
  ------------------
  |  |  277|   224k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|   224k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
  105|   224k|  x32[ 6] = ~x32[ 6];
  106|   224k|  x32[ 7] ^= SWAP32LE(0xcfffffff)^r;
  ------------------
  |  |  277|   224k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|   224k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
  107|   224k|  x32[ 8] = ~x32[ 8];
  108|   224k|  x32[ 9] ^= SWAP32LE(0xbfffffff)^r;
  ------------------
  |  |  277|   224k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|   224k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
  109|   224k|  x32[10] = ~x32[10];
  110|   224k|  x32[11] ^= SWAP32LE(0xafffffff)^r;
  ------------------
  |  |  277|   224k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|   224k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
  111|   224k|  x32[12] = ~x32[12];
  112|   224k|  x32[13] ^= SWAP32LE(0x9fffffff)^r;
  ------------------
  |  |  277|   224k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|   224k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
  113|   224k|  x32[14] = ~x32[14];
  114|   224k|  x32[15] ^= SWAP32LE(0x8fffffff)^r;
  ------------------
  |  |  277|   224k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|   224k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
  115|       |
  116|   224k|  COLUMN(x,y, 0,  2,  6, 10, 14,  1,  5,  9, 13, temp_v1, temp_v2, temp_upper_value, temp_lower_value, temp);
  ------------------
  |  |   35|   224k|   tu = T[2*(uint32_t)x[4*c0+0]];			    \
  |  |   36|   224k|   tl = T[2*(uint32_t)x[4*c0+0]+1];		    \
  |  |   37|   224k|   tv1 = T[2*(uint32_t)x[4*c1+1]];			\
  |  |   38|   224k|   tv2 = T[2*(uint32_t)x[4*c1+1]+1];			\
  |  |   39|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,1,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   40|   224k|   tu ^= tv1;						\
  |  |   41|   224k|   tl ^= tv2;						\
  |  |   42|   224k|   tv1 = T[2*(uint32_t)x[4*c2+2]];			\
  |  |   43|   224k|   tv2 = T[2*(uint32_t)x[4*c2+2]+1];			\
  |  |   44|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,2,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   45|   224k|   tu ^= tv1;						\
  |  |   46|   224k|   tl ^= tv2;   					\
  |  |   47|   224k|   tv1 = T[2*(uint32_t)x[4*c3+3]];			\
  |  |   48|   224k|   tv2 = T[2*(uint32_t)x[4*c3+3]+1];			\
  |  |   49|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,3,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   50|   224k|   tu ^= tv1;						\
  |  |   51|   224k|   tl ^= tv2;						\
  |  |   52|   224k|   tl ^= T[2*(uint32_t)x[4*c4+0]];			\
  |  |   53|   224k|   tu ^= T[2*(uint32_t)x[4*c4+0]+1];			\
  |  |   54|   224k|   tv1 = T[2*(uint32_t)x[4*c5+1]];			\
  |  |   55|   224k|   tv2 = T[2*(uint32_t)x[4*c5+1]+1];			\
  |  |   56|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,1,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   57|   224k|   tl ^= tv1;						\
  |  |   58|   224k|   tu ^= tv2;						\
  |  |   59|   224k|   tv1 = T[2*(uint32_t)x[4*c6+2]];			\
  |  |   60|   224k|   tv2 = T[2*(uint32_t)x[4*c6+2]+1];			\
  |  |   61|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,2,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   62|   224k|   tl ^= tv1;						\
  |  |   63|   224k|   tu ^= tv2;   					\
  |  |   64|   224k|   tv1 = T[2*(uint32_t)x[4*c7+3]];			\
  |  |   65|   224k|   tv2 = T[2*(uint32_t)x[4*c7+3]+1];			\
  |  |   66|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,3,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   67|   224k|   tl ^= tv1;						\
  |  |   68|   224k|   tu ^= tv2;						\
  |  |   69|   224k|   y[i] = tu;						\
  |  |   70|   224k|   y[i+1] = tl;
  ------------------
  117|   224k|  COLUMN(x,y, 2,  4,  8, 12,  0,  3,  7, 11, 15, temp_v1, temp_v2, temp_upper_value, temp_lower_value, temp);
  ------------------
  |  |   35|   224k|   tu = T[2*(uint32_t)x[4*c0+0]];			    \
  |  |   36|   224k|   tl = T[2*(uint32_t)x[4*c0+0]+1];		    \
  |  |   37|   224k|   tv1 = T[2*(uint32_t)x[4*c1+1]];			\
  |  |   38|   224k|   tv2 = T[2*(uint32_t)x[4*c1+1]+1];			\
  |  |   39|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,1,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   40|   224k|   tu ^= tv1;						\
  |  |   41|   224k|   tl ^= tv2;						\
  |  |   42|   224k|   tv1 = T[2*(uint32_t)x[4*c2+2]];			\
  |  |   43|   224k|   tv2 = T[2*(uint32_t)x[4*c2+2]+1];			\
  |  |   44|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,2,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   45|   224k|   tu ^= tv1;						\
  |  |   46|   224k|   tl ^= tv2;   					\
  |  |   47|   224k|   tv1 = T[2*(uint32_t)x[4*c3+3]];			\
  |  |   48|   224k|   tv2 = T[2*(uint32_t)x[4*c3+3]+1];			\
  |  |   49|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,3,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   50|   224k|   tu ^= tv1;						\
  |  |   51|   224k|   tl ^= tv2;						\
  |  |   52|   224k|   tl ^= T[2*(uint32_t)x[4*c4+0]];			\
  |  |   53|   224k|   tu ^= T[2*(uint32_t)x[4*c4+0]+1];			\
  |  |   54|   224k|   tv1 = T[2*(uint32_t)x[4*c5+1]];			\
  |  |   55|   224k|   tv2 = T[2*(uint32_t)x[4*c5+1]+1];			\
  |  |   56|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,1,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   57|   224k|   tl ^= tv1;						\
  |  |   58|   224k|   tu ^= tv2;						\
  |  |   59|   224k|   tv1 = T[2*(uint32_t)x[4*c6+2]];			\
  |  |   60|   224k|   tv2 = T[2*(uint32_t)x[4*c6+2]+1];			\
  |  |   61|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,2,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   62|   224k|   tl ^= tv1;						\
  |  |   63|   224k|   tu ^= tv2;   					\
  |  |   64|   224k|   tv1 = T[2*(uint32_t)x[4*c7+3]];			\
  |  |   65|   224k|   tv2 = T[2*(uint32_t)x[4*c7+3]+1];			\
  |  |   66|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,3,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   67|   224k|   tl ^= tv1;						\
  |  |   68|   224k|   tu ^= tv2;						\
  |  |   69|   224k|   y[i] = tu;						\
  |  |   70|   224k|   y[i+1] = tl;
  ------------------
  118|   224k|  COLUMN(x,y, 4,  6, 10, 14,  2,  5,  9, 13,  1, temp_v1, temp_v2, temp_upper_value, temp_lower_value, temp);
  ------------------
  |  |   35|   224k|   tu = T[2*(uint32_t)x[4*c0+0]];			    \
  |  |   36|   224k|   tl = T[2*(uint32_t)x[4*c0+0]+1];		    \
  |  |   37|   224k|   tv1 = T[2*(uint32_t)x[4*c1+1]];			\
  |  |   38|   224k|   tv2 = T[2*(uint32_t)x[4*c1+1]+1];			\
  |  |   39|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,1,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   40|   224k|   tu ^= tv1;						\
  |  |   41|   224k|   tl ^= tv2;						\
  |  |   42|   224k|   tv1 = T[2*(uint32_t)x[4*c2+2]];			\
  |  |   43|   224k|   tv2 = T[2*(uint32_t)x[4*c2+2]+1];			\
  |  |   44|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,2,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   45|   224k|   tu ^= tv1;						\
  |  |   46|   224k|   tl ^= tv2;   					\
  |  |   47|   224k|   tv1 = T[2*(uint32_t)x[4*c3+3]];			\
  |  |   48|   224k|   tv2 = T[2*(uint32_t)x[4*c3+3]+1];			\
  |  |   49|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,3,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   50|   224k|   tu ^= tv1;						\
  |  |   51|   224k|   tl ^= tv2;						\
  |  |   52|   224k|   tl ^= T[2*(uint32_t)x[4*c4+0]];			\
  |  |   53|   224k|   tu ^= T[2*(uint32_t)x[4*c4+0]+1];			\
  |  |   54|   224k|   tv1 = T[2*(uint32_t)x[4*c5+1]];			\
  |  |   55|   224k|   tv2 = T[2*(uint32_t)x[4*c5+1]+1];			\
  |  |   56|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,1,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   57|   224k|   tl ^= tv1;						\
  |  |   58|   224k|   tu ^= tv2;						\
  |  |   59|   224k|   tv1 = T[2*(uint32_t)x[4*c6+2]];			\
  |  |   60|   224k|   tv2 = T[2*(uint32_t)x[4*c6+2]+1];			\
  |  |   61|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,2,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   62|   224k|   tl ^= tv1;						\
  |  |   63|   224k|   tu ^= tv2;   					\
  |  |   64|   224k|   tv1 = T[2*(uint32_t)x[4*c7+3]];			\
  |  |   65|   224k|   tv2 = T[2*(uint32_t)x[4*c7+3]+1];			\
  |  |   66|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,3,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   67|   224k|   tl ^= tv1;						\
  |  |   68|   224k|   tu ^= tv2;						\
  |  |   69|   224k|   y[i] = tu;						\
  |  |   70|   224k|   y[i+1] = tl;
  ------------------
  119|   224k|  COLUMN(x,y, 6,  8, 12,  0,  4,  7, 11, 15,  3, temp_v1, temp_v2, temp_upper_value, temp_lower_value, temp);
  ------------------
  |  |   35|   224k|   tu = T[2*(uint32_t)x[4*c0+0]];			    \
  |  |   36|   224k|   tl = T[2*(uint32_t)x[4*c0+0]+1];		    \
  |  |   37|   224k|   tv1 = T[2*(uint32_t)x[4*c1+1]];			\
  |  |   38|   224k|   tv2 = T[2*(uint32_t)x[4*c1+1]+1];			\
  |  |   39|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,1,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   40|   224k|   tu ^= tv1;						\
  |  |   41|   224k|   tl ^= tv2;						\
  |  |   42|   224k|   tv1 = T[2*(uint32_t)x[4*c2+2]];			\
  |  |   43|   224k|   tv2 = T[2*(uint32_t)x[4*c2+2]+1];			\
  |  |   44|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,2,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   45|   224k|   tu ^= tv1;						\
  |  |   46|   224k|   tl ^= tv2;   					\
  |  |   47|   224k|   tv1 = T[2*(uint32_t)x[4*c3+3]];			\
  |  |   48|   224k|   tv2 = T[2*(uint32_t)x[4*c3+3]+1];			\
  |  |   49|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,3,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   50|   224k|   tu ^= tv1;						\
  |  |   51|   224k|   tl ^= tv2;						\
  |  |   52|   224k|   tl ^= T[2*(uint32_t)x[4*c4+0]];			\
  |  |   53|   224k|   tu ^= T[2*(uint32_t)x[4*c4+0]+1];			\
  |  |   54|   224k|   tv1 = T[2*(uint32_t)x[4*c5+1]];			\
  |  |   55|   224k|   tv2 = T[2*(uint32_t)x[4*c5+1]+1];			\
  |  |   56|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,1,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   57|   224k|   tl ^= tv1;						\
  |  |   58|   224k|   tu ^= tv2;						\
  |  |   59|   224k|   tv1 = T[2*(uint32_t)x[4*c6+2]];			\
  |  |   60|   224k|   tv2 = T[2*(uint32_t)x[4*c6+2]+1];			\
  |  |   61|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,2,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   62|   224k|   tl ^= tv1;						\
  |  |   63|   224k|   tu ^= tv2;   					\
  |  |   64|   224k|   tv1 = T[2*(uint32_t)x[4*c7+3]];			\
  |  |   65|   224k|   tv2 = T[2*(uint32_t)x[4*c7+3]+1];			\
  |  |   66|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,3,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   67|   224k|   tl ^= tv1;						\
  |  |   68|   224k|   tu ^= tv2;						\
  |  |   69|   224k|   y[i] = tu;						\
  |  |   70|   224k|   y[i+1] = tl;
  ------------------
  120|   224k|  COLUMN(x,y, 8, 10, 14,  2,  6,  9, 13,  1,  5, temp_v1, temp_v2, temp_upper_value, temp_lower_value, temp);
  ------------------
  |  |   35|   224k|   tu = T[2*(uint32_t)x[4*c0+0]];			    \
  |  |   36|   224k|   tl = T[2*(uint32_t)x[4*c0+0]+1];		    \
  |  |   37|   224k|   tv1 = T[2*(uint32_t)x[4*c1+1]];			\
  |  |   38|   224k|   tv2 = T[2*(uint32_t)x[4*c1+1]+1];			\
  |  |   39|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,1,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   40|   224k|   tu ^= tv1;						\
  |  |   41|   224k|   tl ^= tv2;						\
  |  |   42|   224k|   tv1 = T[2*(uint32_t)x[4*c2+2]];			\
  |  |   43|   224k|   tv2 = T[2*(uint32_t)x[4*c2+2]+1];			\
  |  |   44|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,2,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   45|   224k|   tu ^= tv1;						\
  |  |   46|   224k|   tl ^= tv2;   					\
  |  |   47|   224k|   tv1 = T[2*(uint32_t)x[4*c3+3]];			\
  |  |   48|   224k|   tv2 = T[2*(uint32_t)x[4*c3+3]+1];			\
  |  |   49|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,3,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   50|   224k|   tu ^= tv1;						\
  |  |   51|   224k|   tl ^= tv2;						\
  |  |   52|   224k|   tl ^= T[2*(uint32_t)x[4*c4+0]];			\
  |  |   53|   224k|   tu ^= T[2*(uint32_t)x[4*c4+0]+1];			\
  |  |   54|   224k|   tv1 = T[2*(uint32_t)x[4*c5+1]];			\
  |  |   55|   224k|   tv2 = T[2*(uint32_t)x[4*c5+1]+1];			\
  |  |   56|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,1,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   57|   224k|   tl ^= tv1;						\
  |  |   58|   224k|   tu ^= tv2;						\
  |  |   59|   224k|   tv1 = T[2*(uint32_t)x[4*c6+2]];			\
  |  |   60|   224k|   tv2 = T[2*(uint32_t)x[4*c6+2]+1];			\
  |  |   61|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,2,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   62|   224k|   tl ^= tv1;						\
  |  |   63|   224k|   tu ^= tv2;   					\
  |  |   64|   224k|   tv1 = T[2*(uint32_t)x[4*c7+3]];			\
  |  |   65|   224k|   tv2 = T[2*(uint32_t)x[4*c7+3]+1];			\
  |  |   66|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,3,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   67|   224k|   tl ^= tv1;						\
  |  |   68|   224k|   tu ^= tv2;						\
  |  |   69|   224k|   y[i] = tu;						\
  |  |   70|   224k|   y[i+1] = tl;
  ------------------
  121|   224k|  COLUMN(x,y,10, 12,  0,  4,  8, 11, 15,  3,  7, temp_v1, temp_v2, temp_upper_value, temp_lower_value, temp);
  ------------------
  |  |   35|   224k|   tu = T[2*(uint32_t)x[4*c0+0]];			    \
  |  |   36|   224k|   tl = T[2*(uint32_t)x[4*c0+0]+1];		    \
  |  |   37|   224k|   tv1 = T[2*(uint32_t)x[4*c1+1]];			\
  |  |   38|   224k|   tv2 = T[2*(uint32_t)x[4*c1+1]+1];			\
  |  |   39|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,1,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   40|   224k|   tu ^= tv1;						\
  |  |   41|   224k|   tl ^= tv2;						\
  |  |   42|   224k|   tv1 = T[2*(uint32_t)x[4*c2+2]];			\
  |  |   43|   224k|   tv2 = T[2*(uint32_t)x[4*c2+2]+1];			\
  |  |   44|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,2,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   45|   224k|   tu ^= tv1;						\
  |  |   46|   224k|   tl ^= tv2;   					\
  |  |   47|   224k|   tv1 = T[2*(uint32_t)x[4*c3+3]];			\
  |  |   48|   224k|   tv2 = T[2*(uint32_t)x[4*c3+3]+1];			\
  |  |   49|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,3,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   50|   224k|   tu ^= tv1;						\
  |  |   51|   224k|   tl ^= tv2;						\
  |  |   52|   224k|   tl ^= T[2*(uint32_t)x[4*c4+0]];			\
  |  |   53|   224k|   tu ^= T[2*(uint32_t)x[4*c4+0]+1];			\
  |  |   54|   224k|   tv1 = T[2*(uint32_t)x[4*c5+1]];			\
  |  |   55|   224k|   tv2 = T[2*(uint32_t)x[4*c5+1]+1];			\
  |  |   56|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,1,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   57|   224k|   tl ^= tv1;						\
  |  |   58|   224k|   tu ^= tv2;						\
  |  |   59|   224k|   tv1 = T[2*(uint32_t)x[4*c6+2]];			\
  |  |   60|   224k|   tv2 = T[2*(uint32_t)x[4*c6+2]+1];			\
  |  |   61|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,2,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   62|   224k|   tl ^= tv1;						\
  |  |   63|   224k|   tu ^= tv2;   					\
  |  |   64|   224k|   tv1 = T[2*(uint32_t)x[4*c7+3]];			\
  |  |   65|   224k|   tv2 = T[2*(uint32_t)x[4*c7+3]+1];			\
  |  |   66|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,3,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   67|   224k|   tl ^= tv1;						\
  |  |   68|   224k|   tu ^= tv2;						\
  |  |   69|   224k|   y[i] = tu;						\
  |  |   70|   224k|   y[i+1] = tl;
  ------------------
  122|   224k|  COLUMN(x,y,12, 14,  2,  6, 10, 13,  1,  5,  9, temp_v1, temp_v2, temp_upper_value, temp_lower_value, temp);
  ------------------
  |  |   35|   224k|   tu = T[2*(uint32_t)x[4*c0+0]];			    \
  |  |   36|   224k|   tl = T[2*(uint32_t)x[4*c0+0]+1];		    \
  |  |   37|   224k|   tv1 = T[2*(uint32_t)x[4*c1+1]];			\
  |  |   38|   224k|   tv2 = T[2*(uint32_t)x[4*c1+1]+1];			\
  |  |   39|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,1,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   40|   224k|   tu ^= tv1;						\
  |  |   41|   224k|   tl ^= tv2;						\
  |  |   42|   224k|   tv1 = T[2*(uint32_t)x[4*c2+2]];			\
  |  |   43|   224k|   tv2 = T[2*(uint32_t)x[4*c2+2]+1];			\
  |  |   44|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,2,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   45|   224k|   tu ^= tv1;						\
  |  |   46|   224k|   tl ^= tv2;   					\
  |  |   47|   224k|   tv1 = T[2*(uint32_t)x[4*c3+3]];			\
  |  |   48|   224k|   tv2 = T[2*(uint32_t)x[4*c3+3]+1];			\
  |  |   49|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,3,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   50|   224k|   tu ^= tv1;						\
  |  |   51|   224k|   tl ^= tv2;						\
  |  |   52|   224k|   tl ^= T[2*(uint32_t)x[4*c4+0]];			\
  |  |   53|   224k|   tu ^= T[2*(uint32_t)x[4*c4+0]+1];			\
  |  |   54|   224k|   tv1 = T[2*(uint32_t)x[4*c5+1]];			\
  |  |   55|   224k|   tv2 = T[2*(uint32_t)x[4*c5+1]+1];			\
  |  |   56|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,1,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   57|   224k|   tl ^= tv1;						\
  |  |   58|   224k|   tu ^= tv2;						\
  |  |   59|   224k|   tv1 = T[2*(uint32_t)x[4*c6+2]];			\
  |  |   60|   224k|   tv2 = T[2*(uint32_t)x[4*c6+2]+1];			\
  |  |   61|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,2,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   62|   224k|   tl ^= tv1;						\
  |  |   63|   224k|   tu ^= tv2;   					\
  |  |   64|   224k|   tv1 = T[2*(uint32_t)x[4*c7+3]];			\
  |  |   65|   224k|   tv2 = T[2*(uint32_t)x[4*c7+3]+1];			\
  |  |   66|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,3,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   67|   224k|   tl ^= tv1;						\
  |  |   68|   224k|   tu ^= tv2;						\
  |  |   69|   224k|   y[i] = tu;						\
  |  |   70|   224k|   y[i+1] = tl;
  ------------------
  123|   224k|  COLUMN(x,y,14,  0,  4,  8, 12, 15,  3,  7, 11, temp_v1, temp_v2, temp_upper_value, temp_lower_value, temp);
  ------------------
  |  |   35|   224k|   tu = T[2*(uint32_t)x[4*c0+0]];			    \
  |  |   36|   224k|   tl = T[2*(uint32_t)x[4*c0+0]+1];		    \
  |  |   37|   224k|   tv1 = T[2*(uint32_t)x[4*c1+1]];			\
  |  |   38|   224k|   tv2 = T[2*(uint32_t)x[4*c1+1]+1];			\
  |  |   39|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,1,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   40|   224k|   tu ^= tv1;						\
  |  |   41|   224k|   tl ^= tv2;						\
  |  |   42|   224k|   tv1 = T[2*(uint32_t)x[4*c2+2]];			\
  |  |   43|   224k|   tv2 = T[2*(uint32_t)x[4*c2+2]+1];			\
  |  |   44|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,2,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   45|   224k|   tu ^= tv1;						\
  |  |   46|   224k|   tl ^= tv2;   					\
  |  |   47|   224k|   tv1 = T[2*(uint32_t)x[4*c3+3]];			\
  |  |   48|   224k|   tv2 = T[2*(uint32_t)x[4*c3+3]+1];			\
  |  |   49|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,3,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   50|   224k|   tu ^= tv1;						\
  |  |   51|   224k|   tl ^= tv2;						\
  |  |   52|   224k|   tl ^= T[2*(uint32_t)x[4*c4+0]];			\
  |  |   53|   224k|   tu ^= T[2*(uint32_t)x[4*c4+0]+1];			\
  |  |   54|   224k|   tv1 = T[2*(uint32_t)x[4*c5+1]];			\
  |  |   55|   224k|   tv2 = T[2*(uint32_t)x[4*c5+1]+1];			\
  |  |   56|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,1,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   57|   224k|   tl ^= tv1;						\
  |  |   58|   224k|   tu ^= tv2;						\
  |  |   59|   224k|   tv1 = T[2*(uint32_t)x[4*c6+2]];			\
  |  |   60|   224k|   tv2 = T[2*(uint32_t)x[4*c6+2]+1];			\
  |  |   61|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,2,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   62|   224k|   tl ^= tv1;						\
  |  |   63|   224k|   tu ^= tv2;   					\
  |  |   64|   224k|   tv1 = T[2*(uint32_t)x[4*c7+3]];			\
  |  |   65|   224k|   tv2 = T[2*(uint32_t)x[4*c7+3]+1];			\
  |  |   66|   224k|   ROTATE_COLUMN_DOWN(tv1,tv2,3,t)	\
  |  |  ------------------
  |  |  |  |   24|   224k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   224k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   224k|															v1 = temp_var;}
  |  |  ------------------
  |  |   67|   224k|   tl ^= tv1;						\
  |  |   68|   224k|   tu ^= tv2;						\
  |  |   69|   224k|   y[i] = tu;						\
  |  |   70|   224k|   y[i+1] = tl;
  ------------------
  124|   224k|}
groestl.c:RND512P:
   74|   280k|static void RND512P(uint8_t *x, uint32_t *y, uint32_t r) {
   75|   280k|  uint32_t temp_v1, temp_v2, temp_upper_value, temp_lower_value, temp;
   76|   280k|  uint32_t* x32 = (uint32_t*)x;
   77|   280k|  x32[ 0] ^= SWAP32LE(0x00000000)^r;
  ------------------
  |  |  277|   280k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|   280k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
   78|   280k|  x32[ 2] ^= SWAP32LE(0x00000010)^r;
  ------------------
  |  |  277|   280k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|   280k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
   79|   280k|  x32[ 4] ^= SWAP32LE(0x00000020)^r;
  ------------------
  |  |  277|   280k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|   280k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
   80|   280k|  x32[ 6] ^= SWAP32LE(0x00000030)^r;
  ------------------
  |  |  277|   280k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|   280k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
   81|   280k|  x32[ 8] ^= SWAP32LE(0x00000040)^r;
  ------------------
  |  |  277|   280k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|   280k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
   82|   280k|  x32[10] ^= SWAP32LE(0x00000050)^r;
  ------------------
  |  |  277|   280k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|   280k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
   83|   280k|  x32[12] ^= SWAP32LE(0x00000060)^r;
  ------------------
  |  |  277|   280k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|   280k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
   84|   280k|  x32[14] ^= SWAP32LE(0x00000070)^r;
  ------------------
  |  |  277|   280k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|   280k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
   85|   280k|  COLUMN(x,y, 0,  0,  2,  4,  6,  9, 11, 13, 15, temp_v1, temp_v2, temp_upper_value, temp_lower_value, temp);
  ------------------
  |  |   35|   280k|   tu = T[2*(uint32_t)x[4*c0+0]];			    \
  |  |   36|   280k|   tl = T[2*(uint32_t)x[4*c0+0]+1];		    \
  |  |   37|   280k|   tv1 = T[2*(uint32_t)x[4*c1+1]];			\
  |  |   38|   280k|   tv2 = T[2*(uint32_t)x[4*c1+1]+1];			\
  |  |   39|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,1,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   40|   280k|   tu ^= tv1;						\
  |  |   41|   280k|   tl ^= tv2;						\
  |  |   42|   280k|   tv1 = T[2*(uint32_t)x[4*c2+2]];			\
  |  |   43|   280k|   tv2 = T[2*(uint32_t)x[4*c2+2]+1];			\
  |  |   44|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,2,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   45|   280k|   tu ^= tv1;						\
  |  |   46|   280k|   tl ^= tv2;   					\
  |  |   47|   280k|   tv1 = T[2*(uint32_t)x[4*c3+3]];			\
  |  |   48|   280k|   tv2 = T[2*(uint32_t)x[4*c3+3]+1];			\
  |  |   49|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,3,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   50|   280k|   tu ^= tv1;						\
  |  |   51|   280k|   tl ^= tv2;						\
  |  |   52|   280k|   tl ^= T[2*(uint32_t)x[4*c4+0]];			\
  |  |   53|   280k|   tu ^= T[2*(uint32_t)x[4*c4+0]+1];			\
  |  |   54|   280k|   tv1 = T[2*(uint32_t)x[4*c5+1]];			\
  |  |   55|   280k|   tv2 = T[2*(uint32_t)x[4*c5+1]+1];			\
  |  |   56|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,1,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   57|   280k|   tl ^= tv1;						\
  |  |   58|   280k|   tu ^= tv2;						\
  |  |   59|   280k|   tv1 = T[2*(uint32_t)x[4*c6+2]];			\
  |  |   60|   280k|   tv2 = T[2*(uint32_t)x[4*c6+2]+1];			\
  |  |   61|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,2,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   62|   280k|   tl ^= tv1;						\
  |  |   63|   280k|   tu ^= tv2;   					\
  |  |   64|   280k|   tv1 = T[2*(uint32_t)x[4*c7+3]];			\
  |  |   65|   280k|   tv2 = T[2*(uint32_t)x[4*c7+3]+1];			\
  |  |   66|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,3,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   67|   280k|   tl ^= tv1;						\
  |  |   68|   280k|   tu ^= tv2;						\
  |  |   69|   280k|   y[i] = tu;						\
  |  |   70|   280k|   y[i+1] = tl;
  ------------------
   86|   280k|  COLUMN(x,y, 2,  2,  4,  6,  8, 11, 13, 15,  1, temp_v1, temp_v2, temp_upper_value, temp_lower_value, temp);
  ------------------
  |  |   35|   280k|   tu = T[2*(uint32_t)x[4*c0+0]];			    \
  |  |   36|   280k|   tl = T[2*(uint32_t)x[4*c0+0]+1];		    \
  |  |   37|   280k|   tv1 = T[2*(uint32_t)x[4*c1+1]];			\
  |  |   38|   280k|   tv2 = T[2*(uint32_t)x[4*c1+1]+1];			\
  |  |   39|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,1,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   40|   280k|   tu ^= tv1;						\
  |  |   41|   280k|   tl ^= tv2;						\
  |  |   42|   280k|   tv1 = T[2*(uint32_t)x[4*c2+2]];			\
  |  |   43|   280k|   tv2 = T[2*(uint32_t)x[4*c2+2]+1];			\
  |  |   44|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,2,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   45|   280k|   tu ^= tv1;						\
  |  |   46|   280k|   tl ^= tv2;   					\
  |  |   47|   280k|   tv1 = T[2*(uint32_t)x[4*c3+3]];			\
  |  |   48|   280k|   tv2 = T[2*(uint32_t)x[4*c3+3]+1];			\
  |  |   49|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,3,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   50|   280k|   tu ^= tv1;						\
  |  |   51|   280k|   tl ^= tv2;						\
  |  |   52|   280k|   tl ^= T[2*(uint32_t)x[4*c4+0]];			\
  |  |   53|   280k|   tu ^= T[2*(uint32_t)x[4*c4+0]+1];			\
  |  |   54|   280k|   tv1 = T[2*(uint32_t)x[4*c5+1]];			\
  |  |   55|   280k|   tv2 = T[2*(uint32_t)x[4*c5+1]+1];			\
  |  |   56|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,1,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   57|   280k|   tl ^= tv1;						\
  |  |   58|   280k|   tu ^= tv2;						\
  |  |   59|   280k|   tv1 = T[2*(uint32_t)x[4*c6+2]];			\
  |  |   60|   280k|   tv2 = T[2*(uint32_t)x[4*c6+2]+1];			\
  |  |   61|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,2,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   62|   280k|   tl ^= tv1;						\
  |  |   63|   280k|   tu ^= tv2;   					\
  |  |   64|   280k|   tv1 = T[2*(uint32_t)x[4*c7+3]];			\
  |  |   65|   280k|   tv2 = T[2*(uint32_t)x[4*c7+3]+1];			\
  |  |   66|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,3,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   67|   280k|   tl ^= tv1;						\
  |  |   68|   280k|   tu ^= tv2;						\
  |  |   69|   280k|   y[i] = tu;						\
  |  |   70|   280k|   y[i+1] = tl;
  ------------------
   87|   280k|  COLUMN(x,y, 4,  4,  6,  8, 10, 13, 15,  1,  3, temp_v1, temp_v2, temp_upper_value, temp_lower_value, temp);
  ------------------
  |  |   35|   280k|   tu = T[2*(uint32_t)x[4*c0+0]];			    \
  |  |   36|   280k|   tl = T[2*(uint32_t)x[4*c0+0]+1];		    \
  |  |   37|   280k|   tv1 = T[2*(uint32_t)x[4*c1+1]];			\
  |  |   38|   280k|   tv2 = T[2*(uint32_t)x[4*c1+1]+1];			\
  |  |   39|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,1,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   40|   280k|   tu ^= tv1;						\
  |  |   41|   280k|   tl ^= tv2;						\
  |  |   42|   280k|   tv1 = T[2*(uint32_t)x[4*c2+2]];			\
  |  |   43|   280k|   tv2 = T[2*(uint32_t)x[4*c2+2]+1];			\
  |  |   44|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,2,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   45|   280k|   tu ^= tv1;						\
  |  |   46|   280k|   tl ^= tv2;   					\
  |  |   47|   280k|   tv1 = T[2*(uint32_t)x[4*c3+3]];			\
  |  |   48|   280k|   tv2 = T[2*(uint32_t)x[4*c3+3]+1];			\
  |  |   49|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,3,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   50|   280k|   tu ^= tv1;						\
  |  |   51|   280k|   tl ^= tv2;						\
  |  |   52|   280k|   tl ^= T[2*(uint32_t)x[4*c4+0]];			\
  |  |   53|   280k|   tu ^= T[2*(uint32_t)x[4*c4+0]+1];			\
  |  |   54|   280k|   tv1 = T[2*(uint32_t)x[4*c5+1]];			\
  |  |   55|   280k|   tv2 = T[2*(uint32_t)x[4*c5+1]+1];			\
  |  |   56|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,1,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   57|   280k|   tl ^= tv1;						\
  |  |   58|   280k|   tu ^= tv2;						\
  |  |   59|   280k|   tv1 = T[2*(uint32_t)x[4*c6+2]];			\
  |  |   60|   280k|   tv2 = T[2*(uint32_t)x[4*c6+2]+1];			\
  |  |   61|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,2,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   62|   280k|   tl ^= tv1;						\
  |  |   63|   280k|   tu ^= tv2;   					\
  |  |   64|   280k|   tv1 = T[2*(uint32_t)x[4*c7+3]];			\
  |  |   65|   280k|   tv2 = T[2*(uint32_t)x[4*c7+3]+1];			\
  |  |   66|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,3,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   67|   280k|   tl ^= tv1;						\
  |  |   68|   280k|   tu ^= tv2;						\
  |  |   69|   280k|   y[i] = tu;						\
  |  |   70|   280k|   y[i+1] = tl;
  ------------------
   88|   280k|  COLUMN(x,y, 6,  6,  8, 10, 12, 15,  1,  3,  5, temp_v1, temp_v2, temp_upper_value, temp_lower_value, temp);
  ------------------
  |  |   35|   280k|   tu = T[2*(uint32_t)x[4*c0+0]];			    \
  |  |   36|   280k|   tl = T[2*(uint32_t)x[4*c0+0]+1];		    \
  |  |   37|   280k|   tv1 = T[2*(uint32_t)x[4*c1+1]];			\
  |  |   38|   280k|   tv2 = T[2*(uint32_t)x[4*c1+1]+1];			\
  |  |   39|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,1,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   40|   280k|   tu ^= tv1;						\
  |  |   41|   280k|   tl ^= tv2;						\
  |  |   42|   280k|   tv1 = T[2*(uint32_t)x[4*c2+2]];			\
  |  |   43|   280k|   tv2 = T[2*(uint32_t)x[4*c2+2]+1];			\
  |  |   44|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,2,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   45|   280k|   tu ^= tv1;						\
  |  |   46|   280k|   tl ^= tv2;   					\
  |  |   47|   280k|   tv1 = T[2*(uint32_t)x[4*c3+3]];			\
  |  |   48|   280k|   tv2 = T[2*(uint32_t)x[4*c3+3]+1];			\
  |  |   49|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,3,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   50|   280k|   tu ^= tv1;						\
  |  |   51|   280k|   tl ^= tv2;						\
  |  |   52|   280k|   tl ^= T[2*(uint32_t)x[4*c4+0]];			\
  |  |   53|   280k|   tu ^= T[2*(uint32_t)x[4*c4+0]+1];			\
  |  |   54|   280k|   tv1 = T[2*(uint32_t)x[4*c5+1]];			\
  |  |   55|   280k|   tv2 = T[2*(uint32_t)x[4*c5+1]+1];			\
  |  |   56|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,1,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   57|   280k|   tl ^= tv1;						\
  |  |   58|   280k|   tu ^= tv2;						\
  |  |   59|   280k|   tv1 = T[2*(uint32_t)x[4*c6+2]];			\
  |  |   60|   280k|   tv2 = T[2*(uint32_t)x[4*c6+2]+1];			\
  |  |   61|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,2,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   62|   280k|   tl ^= tv1;						\
  |  |   63|   280k|   tu ^= tv2;   					\
  |  |   64|   280k|   tv1 = T[2*(uint32_t)x[4*c7+3]];			\
  |  |   65|   280k|   tv2 = T[2*(uint32_t)x[4*c7+3]+1];			\
  |  |   66|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,3,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   67|   280k|   tl ^= tv1;						\
  |  |   68|   280k|   tu ^= tv2;						\
  |  |   69|   280k|   y[i] = tu;						\
  |  |   70|   280k|   y[i+1] = tl;
  ------------------
   89|   280k|  COLUMN(x,y, 8,  8, 10, 12, 14,  1,  3,  5,  7, temp_v1, temp_v2, temp_upper_value, temp_lower_value, temp);
  ------------------
  |  |   35|   280k|   tu = T[2*(uint32_t)x[4*c0+0]];			    \
  |  |   36|   280k|   tl = T[2*(uint32_t)x[4*c0+0]+1];		    \
  |  |   37|   280k|   tv1 = T[2*(uint32_t)x[4*c1+1]];			\
  |  |   38|   280k|   tv2 = T[2*(uint32_t)x[4*c1+1]+1];			\
  |  |   39|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,1,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   40|   280k|   tu ^= tv1;						\
  |  |   41|   280k|   tl ^= tv2;						\
  |  |   42|   280k|   tv1 = T[2*(uint32_t)x[4*c2+2]];			\
  |  |   43|   280k|   tv2 = T[2*(uint32_t)x[4*c2+2]+1];			\
  |  |   44|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,2,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   45|   280k|   tu ^= tv1;						\
  |  |   46|   280k|   tl ^= tv2;   					\
  |  |   47|   280k|   tv1 = T[2*(uint32_t)x[4*c3+3]];			\
  |  |   48|   280k|   tv2 = T[2*(uint32_t)x[4*c3+3]+1];			\
  |  |   49|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,3,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   50|   280k|   tu ^= tv1;						\
  |  |   51|   280k|   tl ^= tv2;						\
  |  |   52|   280k|   tl ^= T[2*(uint32_t)x[4*c4+0]];			\
  |  |   53|   280k|   tu ^= T[2*(uint32_t)x[4*c4+0]+1];			\
  |  |   54|   280k|   tv1 = T[2*(uint32_t)x[4*c5+1]];			\
  |  |   55|   280k|   tv2 = T[2*(uint32_t)x[4*c5+1]+1];			\
  |  |   56|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,1,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   57|   280k|   tl ^= tv1;						\
  |  |   58|   280k|   tu ^= tv2;						\
  |  |   59|   280k|   tv1 = T[2*(uint32_t)x[4*c6+2]];			\
  |  |   60|   280k|   tv2 = T[2*(uint32_t)x[4*c6+2]+1];			\
  |  |   61|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,2,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   62|   280k|   tl ^= tv1;						\
  |  |   63|   280k|   tu ^= tv2;   					\
  |  |   64|   280k|   tv1 = T[2*(uint32_t)x[4*c7+3]];			\
  |  |   65|   280k|   tv2 = T[2*(uint32_t)x[4*c7+3]+1];			\
  |  |   66|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,3,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   67|   280k|   tl ^= tv1;						\
  |  |   68|   280k|   tu ^= tv2;						\
  |  |   69|   280k|   y[i] = tu;						\
  |  |   70|   280k|   y[i+1] = tl;
  ------------------
   90|   280k|  COLUMN(x,y,10, 10, 12, 14,  0,  3,  5,  7,  9, temp_v1, temp_v2, temp_upper_value, temp_lower_value, temp);
  ------------------
  |  |   35|   280k|   tu = T[2*(uint32_t)x[4*c0+0]];			    \
  |  |   36|   280k|   tl = T[2*(uint32_t)x[4*c0+0]+1];		    \
  |  |   37|   280k|   tv1 = T[2*(uint32_t)x[4*c1+1]];			\
  |  |   38|   280k|   tv2 = T[2*(uint32_t)x[4*c1+1]+1];			\
  |  |   39|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,1,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   40|   280k|   tu ^= tv1;						\
  |  |   41|   280k|   tl ^= tv2;						\
  |  |   42|   280k|   tv1 = T[2*(uint32_t)x[4*c2+2]];			\
  |  |   43|   280k|   tv2 = T[2*(uint32_t)x[4*c2+2]+1];			\
  |  |   44|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,2,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   45|   280k|   tu ^= tv1;						\
  |  |   46|   280k|   tl ^= tv2;   					\
  |  |   47|   280k|   tv1 = T[2*(uint32_t)x[4*c3+3]];			\
  |  |   48|   280k|   tv2 = T[2*(uint32_t)x[4*c3+3]+1];			\
  |  |   49|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,3,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   50|   280k|   tu ^= tv1;						\
  |  |   51|   280k|   tl ^= tv2;						\
  |  |   52|   280k|   tl ^= T[2*(uint32_t)x[4*c4+0]];			\
  |  |   53|   280k|   tu ^= T[2*(uint32_t)x[4*c4+0]+1];			\
  |  |   54|   280k|   tv1 = T[2*(uint32_t)x[4*c5+1]];			\
  |  |   55|   280k|   tv2 = T[2*(uint32_t)x[4*c5+1]+1];			\
  |  |   56|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,1,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   57|   280k|   tl ^= tv1;						\
  |  |   58|   280k|   tu ^= tv2;						\
  |  |   59|   280k|   tv1 = T[2*(uint32_t)x[4*c6+2]];			\
  |  |   60|   280k|   tv2 = T[2*(uint32_t)x[4*c6+2]+1];			\
  |  |   61|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,2,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   62|   280k|   tl ^= tv1;						\
  |  |   63|   280k|   tu ^= tv2;   					\
  |  |   64|   280k|   tv1 = T[2*(uint32_t)x[4*c7+3]];			\
  |  |   65|   280k|   tv2 = T[2*(uint32_t)x[4*c7+3]+1];			\
  |  |   66|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,3,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   67|   280k|   tl ^= tv1;						\
  |  |   68|   280k|   tu ^= tv2;						\
  |  |   69|   280k|   y[i] = tu;						\
  |  |   70|   280k|   y[i+1] = tl;
  ------------------
   91|   280k|  COLUMN(x,y,12, 12, 14,  0,  2,  5,  7,  9, 11, temp_v1, temp_v2, temp_upper_value, temp_lower_value, temp);
  ------------------
  |  |   35|   280k|   tu = T[2*(uint32_t)x[4*c0+0]];			    \
  |  |   36|   280k|   tl = T[2*(uint32_t)x[4*c0+0]+1];		    \
  |  |   37|   280k|   tv1 = T[2*(uint32_t)x[4*c1+1]];			\
  |  |   38|   280k|   tv2 = T[2*(uint32_t)x[4*c1+1]+1];			\
  |  |   39|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,1,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   40|   280k|   tu ^= tv1;						\
  |  |   41|   280k|   tl ^= tv2;						\
  |  |   42|   280k|   tv1 = T[2*(uint32_t)x[4*c2+2]];			\
  |  |   43|   280k|   tv2 = T[2*(uint32_t)x[4*c2+2]+1];			\
  |  |   44|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,2,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   45|   280k|   tu ^= tv1;						\
  |  |   46|   280k|   tl ^= tv2;   					\
  |  |   47|   280k|   tv1 = T[2*(uint32_t)x[4*c3+3]];			\
  |  |   48|   280k|   tv2 = T[2*(uint32_t)x[4*c3+3]+1];			\
  |  |   49|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,3,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   50|   280k|   tu ^= tv1;						\
  |  |   51|   280k|   tl ^= tv2;						\
  |  |   52|   280k|   tl ^= T[2*(uint32_t)x[4*c4+0]];			\
  |  |   53|   280k|   tu ^= T[2*(uint32_t)x[4*c4+0]+1];			\
  |  |   54|   280k|   tv1 = T[2*(uint32_t)x[4*c5+1]];			\
  |  |   55|   280k|   tv2 = T[2*(uint32_t)x[4*c5+1]+1];			\
  |  |   56|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,1,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   57|   280k|   tl ^= tv1;						\
  |  |   58|   280k|   tu ^= tv2;						\
  |  |   59|   280k|   tv1 = T[2*(uint32_t)x[4*c6+2]];			\
  |  |   60|   280k|   tv2 = T[2*(uint32_t)x[4*c6+2]+1];			\
  |  |   61|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,2,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   62|   280k|   tl ^= tv1;						\
  |  |   63|   280k|   tu ^= tv2;   					\
  |  |   64|   280k|   tv1 = T[2*(uint32_t)x[4*c7+3]];			\
  |  |   65|   280k|   tv2 = T[2*(uint32_t)x[4*c7+3]+1];			\
  |  |   66|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,3,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   67|   280k|   tl ^= tv1;						\
  |  |   68|   280k|   tu ^= tv2;						\
  |  |   69|   280k|   y[i] = tu;						\
  |  |   70|   280k|   y[i+1] = tl;
  ------------------
   92|   280k|  COLUMN(x,y,14, 14,  0,  2,  4,  7,  9, 11, 13, temp_v1, temp_v2, temp_upper_value, temp_lower_value, temp);
  ------------------
  |  |   35|   280k|   tu = T[2*(uint32_t)x[4*c0+0]];			    \
  |  |   36|   280k|   tl = T[2*(uint32_t)x[4*c0+0]+1];		    \
  |  |   37|   280k|   tv1 = T[2*(uint32_t)x[4*c1+1]];			\
  |  |   38|   280k|   tv2 = T[2*(uint32_t)x[4*c1+1]+1];			\
  |  |   39|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,1,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   40|   280k|   tu ^= tv1;						\
  |  |   41|   280k|   tl ^= tv2;						\
  |  |   42|   280k|   tv1 = T[2*(uint32_t)x[4*c2+2]];			\
  |  |   43|   280k|   tv2 = T[2*(uint32_t)x[4*c2+2]+1];			\
  |  |   44|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,2,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   45|   280k|   tu ^= tv1;						\
  |  |   46|   280k|   tl ^= tv2;   					\
  |  |   47|   280k|   tv1 = T[2*(uint32_t)x[4*c3+3]];			\
  |  |   48|   280k|   tv2 = T[2*(uint32_t)x[4*c3+3]+1];			\
  |  |   49|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,3,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   50|   280k|   tu ^= tv1;						\
  |  |   51|   280k|   tl ^= tv2;						\
  |  |   52|   280k|   tl ^= T[2*(uint32_t)x[4*c4+0]];			\
  |  |   53|   280k|   tu ^= T[2*(uint32_t)x[4*c4+0]+1];			\
  |  |   54|   280k|   tv1 = T[2*(uint32_t)x[4*c5+1]];			\
  |  |   55|   280k|   tv2 = T[2*(uint32_t)x[4*c5+1]+1];			\
  |  |   56|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,1,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   57|   280k|   tl ^= tv1;						\
  |  |   58|   280k|   tu ^= tv2;						\
  |  |   59|   280k|   tv1 = T[2*(uint32_t)x[4*c6+2]];			\
  |  |   60|   280k|   tv2 = T[2*(uint32_t)x[4*c6+2]+1];			\
  |  |   61|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,2,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   62|   280k|   tl ^= tv1;						\
  |  |   63|   280k|   tu ^= tv2;   					\
  |  |   64|   280k|   tv1 = T[2*(uint32_t)x[4*c7+3]];			\
  |  |   65|   280k|   tv2 = T[2*(uint32_t)x[4*c7+3]+1];			\
  |  |   66|   280k|   ROTATE_COLUMN_DOWN(tv1,tv2,3,t)	\
  |  |  ------------------
  |  |  |  |   24|   280k|#define ROTATE_COLUMN_DOWN(v1, v2, amount_bytes, temp_var) {temp_var = (v1<<(8*amount_bytes))|(v2>>(8*(4-amount_bytes))); \
  |  |  |  |   25|   280k|															v2 = (v2<<(8*amount_bytes))|(v1>>(8*(4-amount_bytes))); \
  |  |  |  |   26|   280k|															v1 = temp_var;}
  |  |  ------------------
  |  |   67|   280k|   tl ^= tv1;						\
  |  |   68|   280k|   tu ^= tv2;						\
  |  |   69|   280k|   y[i] = tu;						\
  |  |   70|   280k|   y[i+1] = tl;
  ------------------
   93|   280k|}
groestl.c:Final:
  283|  5.60k|		 BitSequence* output) {
  284|  5.60k|  int i, j = 0, hashbytelen = HASH_BIT_LEN/8;
  ------------------
  |  |   51|  5.60k|#define HASH_BIT_LEN 256
  ------------------
  285|  5.60k|  uint8_t *s = (BitSequence*)ctx->chaining;
  286|       |
  287|       |  /* pad with '1'-bit and first few '0'-bits */
  288|  5.60k|  if (BILB) {
  ------------------
  |  |  278|  5.60k|#define BILB ctx->bits_in_last_byte
  |  |  ------------------
  |  |  |  Branch (278:14): [True: 0, False: 5.60k]
  |  |  ------------------
  ------------------
  289|      0|    ctx->buffer[(int)ctx->buf_ptr-1] &= ((1<<BILB)-1)<<(8-BILB);
  ------------------
  |  |  278|      0|#define BILB ctx->bits_in_last_byte
  ------------------
                  ctx->buffer[(int)ctx->buf_ptr-1] &= ((1<<BILB)-1)<<(8-BILB);
  ------------------
  |  |  278|      0|#define BILB ctx->bits_in_last_byte
  ------------------
  290|      0|    ctx->buffer[(int)ctx->buf_ptr-1] ^= 0x1<<(7-BILB);
  ------------------
  |  |  278|      0|#define BILB ctx->bits_in_last_byte
  ------------------
  291|      0|    BILB = 0;
  ------------------
  |  |  278|      0|#define BILB ctx->bits_in_last_byte
  ------------------
  292|      0|  }
  293|  5.60k|  else ctx->buffer[(int)ctx->buf_ptr++] = 0x80;
  294|       |
  295|       |  /* pad with '0'-bits */
  296|  5.60k|  if (ctx->buf_ptr > SIZE512-LENGTHFIELDLEN) {
  ------------------
  |  |   48|  5.60k|#define SIZE512 (ROWS*COLS512)
  |  |  ------------------
  |  |  |  |   44|  5.60k|#define ROWS 8
  |  |  ------------------
  |  |               #define SIZE512 (ROWS*COLS512)
  |  |  ------------------
  |  |  |  |   46|  5.60k|#define COLS512 8
  |  |  ------------------
  ------------------
                if (ctx->buf_ptr > SIZE512-LENGTHFIELDLEN) {
  ------------------
  |  |   45|  5.60k|#define LENGTHFIELDLEN ROWS
  |  |  ------------------
  |  |  |  |   44|  5.60k|#define ROWS 8
  |  |  ------------------
  ------------------
  |  Branch (296:7): [True: 0, False: 5.60k]
  ------------------
  297|       |    /* padding requires two blocks */
  298|      0|    while (ctx->buf_ptr < SIZE512) {
  ------------------
  |  |   48|      0|#define SIZE512 (ROWS*COLS512)
  |  |  ------------------
  |  |  |  |   44|      0|#define ROWS 8
  |  |  ------------------
  |  |               #define SIZE512 (ROWS*COLS512)
  |  |  ------------------
  |  |  |  |   46|      0|#define COLS512 8
  |  |  ------------------
  ------------------
  |  Branch (298:12): [True: 0, False: 0]
  ------------------
  299|      0|      ctx->buffer[(int)ctx->buf_ptr++] = 0;
  300|      0|    }
  301|       |    /* digest first padding block */
  302|      0|    Transform(ctx, ctx->buffer, SIZE512);
  ------------------
  |  |   48|      0|#define SIZE512 (ROWS*COLS512)
  |  |  ------------------
  |  |  |  |   44|      0|#define ROWS 8
  |  |  ------------------
  |  |               #define SIZE512 (ROWS*COLS512)
  |  |  ------------------
  |  |  |  |   46|      0|#define COLS512 8
  |  |  ------------------
  ------------------
  303|      0|    ctx->buf_ptr = 0;
  304|      0|  }
  305|   268k|  while (ctx->buf_ptr < SIZE512-LENGTHFIELDLEN) {
  ------------------
  |  |   48|   268k|#define SIZE512 (ROWS*COLS512)
  |  |  ------------------
  |  |  |  |   44|   268k|#define ROWS 8
  |  |  ------------------
  |  |               #define SIZE512 (ROWS*COLS512)
  |  |  ------------------
  |  |  |  |   46|   268k|#define COLS512 8
  |  |  ------------------
  ------------------
                while (ctx->buf_ptr < SIZE512-LENGTHFIELDLEN) {
  ------------------
  |  |   45|   268k|#define LENGTHFIELDLEN ROWS
  |  |  ------------------
  |  |  |  |   44|   268k|#define ROWS 8
  |  |  ------------------
  ------------------
  |  Branch (305:10): [True: 263k, False: 5.60k]
  ------------------
  306|   263k|    ctx->buffer[(int)ctx->buf_ptr++] = 0;
  307|   263k|  }
  308|       |
  309|       |  /* length padding */
  310|  5.60k|  ctx->block_counter1++;
  311|  5.60k|  if (ctx->block_counter1 == 0) ctx->block_counter2++;
  ------------------
  |  Branch (311:7): [True: 0, False: 5.60k]
  ------------------
  312|  5.60k|  ctx->buf_ptr = SIZE512;
  ------------------
  |  |   48|  5.60k|#define SIZE512 (ROWS*COLS512)
  |  |  ------------------
  |  |  |  |   44|  5.60k|#define ROWS 8
  |  |  ------------------
  |  |               #define SIZE512 (ROWS*COLS512)
  |  |  ------------------
  |  |  |  |   46|  5.60k|#define COLS512 8
  |  |  ------------------
  ------------------
  313|       |
  314|  28.0k|  while (ctx->buf_ptr > SIZE512-(int)sizeof(uint32_t)) {
  ------------------
  |  |   48|  28.0k|#define SIZE512 (ROWS*COLS512)
  |  |  ------------------
  |  |  |  |   44|  28.0k|#define ROWS 8
  |  |  ------------------
  |  |               #define SIZE512 (ROWS*COLS512)
  |  |  ------------------
  |  |  |  |   46|  28.0k|#define COLS512 8
  |  |  ------------------
  ------------------
  |  Branch (314:10): [True: 22.4k, False: 5.60k]
  ------------------
  315|  22.4k|    ctx->buffer[(int)--ctx->buf_ptr] = (uint8_t)ctx->block_counter1;
  316|  22.4k|    ctx->block_counter1 >>= 8;
  317|  22.4k|  }
  318|  28.0k|  while (ctx->buf_ptr > SIZE512-LENGTHFIELDLEN) {
  ------------------
  |  |   48|  28.0k|#define SIZE512 (ROWS*COLS512)
  |  |  ------------------
  |  |  |  |   44|  28.0k|#define ROWS 8
  |  |  ------------------
  |  |               #define SIZE512 (ROWS*COLS512)
  |  |  ------------------
  |  |  |  |   46|  28.0k|#define COLS512 8
  |  |  ------------------
  ------------------
                while (ctx->buf_ptr > SIZE512-LENGTHFIELDLEN) {
  ------------------
  |  |   45|  28.0k|#define LENGTHFIELDLEN ROWS
  |  |  ------------------
  |  |  |  |   44|  28.0k|#define ROWS 8
  |  |  ------------------
  ------------------
  |  Branch (318:10): [True: 22.4k, False: 5.60k]
  ------------------
  319|  22.4k|    ctx->buffer[(int)--ctx->buf_ptr] = (uint8_t)ctx->block_counter2;
  320|  22.4k|    ctx->block_counter2 >>= 8;
  321|  22.4k|  }
  322|       |  /* digest final padding block */
  323|  5.60k|  Transform(ctx, ctx->buffer, SIZE512); 
  ------------------
  |  |   48|  5.60k|#define SIZE512 (ROWS*COLS512)
  |  |  ------------------
  |  |  |  |   44|  5.60k|#define ROWS 8
  |  |  ------------------
  |  |               #define SIZE512 (ROWS*COLS512)
  |  |  ------------------
  |  |  |  |   46|  5.60k|#define COLS512 8
  |  |  ------------------
  ------------------
  324|       |  /* perform output transformation */
  325|  5.60k|  OutputTransformation(ctx);
  326|       |
  327|       |  /* store hash result in output */
  328|   184k|  for (i = SIZE512-hashbytelen; i < SIZE512; i++,j++) {
  ------------------
  |  |   48|  5.60k|#define SIZE512 (ROWS*COLS512)
  |  |  ------------------
  |  |  |  |   44|  5.60k|#define ROWS 8
  |  |  ------------------
  |  |               #define SIZE512 (ROWS*COLS512)
  |  |  ------------------
  |  |  |  |   46|  5.60k|#define COLS512 8
  |  |  ------------------
  ------------------
                for (i = SIZE512-hashbytelen; i < SIZE512; i++,j++) {
  ------------------
  |  |   48|   184k|#define SIZE512 (ROWS*COLS512)
  |  |  ------------------
  |  |  |  |   44|   184k|#define ROWS 8
  |  |  ------------------
  |  |               #define SIZE512 (ROWS*COLS512)
  |  |  ------------------
  |  |  |  |   46|   184k|#define COLS512 8
  |  |  ------------------
  ------------------
  |  Branch (328:33): [True: 179k, False: 5.60k]
  ------------------
  329|   179k|    output[j] = s[i];
  330|   179k|  }
  331|       |
  332|       |  /* zeroise relevant variables and deallocate memory */
  333|  50.4k|  for (i = 0; i < COLS512; i++) {
  ------------------
  |  |   46|  50.4k|#define COLS512 8
  ------------------
  |  Branch (333:15): [True: 44.8k, False: 5.60k]
  ------------------
  334|  44.8k|    ctx->chaining[i] = 0;
  335|  44.8k|  }
  336|   364k|  for (i = 0; i < SIZE512; i++) {
  ------------------
  |  |   48|   364k|#define SIZE512 (ROWS*COLS512)
  |  |  ------------------
  |  |  |  |   44|   364k|#define ROWS 8
  |  |  ------------------
  |  |               #define SIZE512 (ROWS*COLS512)
  |  |  ------------------
  |  |  |  |   46|   364k|#define COLS512 8
  |  |  ------------------
  ------------------
  |  Branch (336:15): [True: 358k, False: 5.60k]
  ------------------
  337|   358k|    ctx->buffer[i] = 0;
  338|   358k|  }
  339|  5.60k|}
groestl.c:OutputTransformation:
  187|  5.60k|static void OutputTransformation(hashState *ctx) {
  188|  5.60k|  int j;
  189|  5.60k|  uint32_t temp[2*COLS512];
  190|  5.60k|  uint32_t y[2*COLS512];
  191|  5.60k|  uint32_t z[2*COLS512];
  192|       |
  193|       |
  194|       |
  195|  95.2k|	for (j = 0; j < 2*COLS512; j++) {
  ------------------
  |  |   46|  95.2k|#define COLS512 8
  ------------------
  |  Branch (195:14): [True: 89.6k, False: 5.60k]
  ------------------
  196|  89.6k|	  temp[j] = ctx->chaining[j];
  197|  89.6k|	}
  198|  5.60k|	RND512P((uint8_t*)temp, y, SWAP32LE(0x00000000));
  ------------------
  |  |  277|  5.60k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|  5.60k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
  199|  5.60k|	RND512P((uint8_t*)y, z, SWAP32LE(0x00000001));
  ------------------
  |  |  277|  5.60k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|  5.60k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
  200|  5.60k|	RND512P((uint8_t*)z, y, SWAP32LE(0x00000002));
  ------------------
  |  |  277|  5.60k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|  5.60k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
  201|  5.60k|	RND512P((uint8_t*)y, z, SWAP32LE(0x00000003));
  ------------------
  |  |  277|  5.60k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|  5.60k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
  202|  5.60k|	RND512P((uint8_t*)z, y, SWAP32LE(0x00000004));
  ------------------
  |  |  277|  5.60k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|  5.60k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
  203|  5.60k|	RND512P((uint8_t*)y, z, SWAP32LE(0x00000005));
  ------------------
  |  |  277|  5.60k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|  5.60k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
  204|  5.60k|	RND512P((uint8_t*)z, y, SWAP32LE(0x00000006));
  ------------------
  |  |  277|  5.60k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|  5.60k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
  205|  5.60k|	RND512P((uint8_t*)y, z, SWAP32LE(0x00000007));
  ------------------
  |  |  277|  5.60k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|  5.60k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
  206|  5.60k|	RND512P((uint8_t*)z, y, SWAP32LE(0x00000008));
  ------------------
  |  |  277|  5.60k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|  5.60k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
  207|  5.60k|	RND512P((uint8_t*)y, temp, SWAP32LE(0x00000009));
  ------------------
  |  |  277|  5.60k|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|  5.60k|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
  208|  95.2k|	for (j = 0; j < 2*COLS512; j++) {
  ------------------
  |  |   46|  95.2k|#define COLS512 8
  ------------------
  |  Branch (208:14): [True: 89.6k, False: 5.60k]
  ------------------
  209|  89.6k|	  ctx->chaining[j] ^= temp[j];
  210|  89.6k|	}									  
  211|  5.60k|}

hash_extra_blake:
   36|      1|void hash_extra_blake(const void *data, size_t length, char *hash) {
   37|      1|  blake256_hash((uint8_t*)hash, data, length);
   38|      1|}

hash_extra_groestl:
   36|  5.60k|void hash_extra_groestl(const void *data, size_t length, char *hash) {
   37|  5.60k|  groestl(data, length * 8, (uint8_t*)hash);
   38|  5.60k|}

hash_permutation:
   38|   121k|void hash_permutation(union hash_state *state) {
   39|   121k|#if BYTE_ORDER == LITTLE_ENDIAN
   40|   121k|  keccakf((uint64_t*)state, 24);
   41|       |#else
   42|       |  uint64_t le_state[25];
   43|       |  memcpy_swap64le(le_state, state, 25);
   44|       |  keccakf(le_state, 24);
   45|       |  memcpy_swap64le(state, le_state, 25);
   46|       |#endif
   47|   121k|}
hash_process:
   49|  28.4k|void hash_process(union hash_state *state, const uint8_t *buf, size_t count) {
   50|  28.4k|  keccak1600(buf, count, (uint8_t*)state);
   51|  28.4k|}
cn_fast_hash:
   53|  22.8k|void cn_fast_hash(const void *data, size_t length, char *hash) {
   54|  22.8k|  union hash_state state;
   55|  22.8k|  hash_process(&state, data, length);
   56|  22.8k|  memcpy(hash, &state, HASH_SIZE);
   57|  22.8k|}

_ZN6crypto12cn_fast_hashEPKvmRNS_4hashE:
   63|  22.8k|  inline void cn_fast_hash(const void *data, std::size_t length, hash &hash) {
   64|  22.8k|    cn_fast_hash(data, length, reinterpret_cast<char *>(&hash));
   65|  22.8k|  }
_ZN6crypto12cn_slow_hashEPKvmRNS_4hashEim:
   73|      1|  inline void cn_slow_hash(const void *data, std::size_t length, hash &hash, int variant = 0, uint64_t height = 0) {
   74|      1|    cn_slow_hash(data, length, reinterpret_cast<char *>(&hash), variant, 0/*prehashed*/, height);
   75|      1|  }
_ZN6crypto9tree_hashEPKNS_4hashEmRS0_:
   81|      2|  inline void tree_hash(const hash *hashes, std::size_t count, hash &root_hash) {
   82|      2|    tree_hash(reinterpret_cast<const char (*)[HASH_SIZE]>(hashes), count, reinterpret_cast<char *>(&root_hash));
   83|      2|  }

keccakf:
   37|   159k|{
   38|   159k|    int round;
   39|   159k|    uint64_t t, bc[5];
   40|       |
   41|  3.97M|    for (round = 0; round < rounds; ++round) {
  ------------------
  |  Branch (41:21): [True: 3.81M, False: 159k]
  ------------------
   42|       |        // Theta
   43|  3.81M|        bc[0] = st[0] ^ st[5] ^ st[10] ^ st[15] ^ st[20];
   44|  3.81M|        bc[1] = st[1] ^ st[6] ^ st[11] ^ st[16] ^ st[21];
   45|  3.81M|        bc[2] = st[2] ^ st[7] ^ st[12] ^ st[17] ^ st[22];
   46|  3.81M|        bc[3] = st[3] ^ st[8] ^ st[13] ^ st[18] ^ st[23];
   47|  3.81M|        bc[4] = st[4] ^ st[9] ^ st[14] ^ st[19] ^ st[24];
   48|       |
   49|  3.81M|#define THETA(i) { \
   50|  3.81M|            t = bc[(i + 4) % 5] ^ ROTL64(bc[(i + 1) % 5], 1); \
   51|  3.81M|            st[i     ] ^= t; \
   52|  3.81M|            st[i +  5] ^= t; \
   53|  3.81M|            st[i + 10] ^= t; \
   54|  3.81M|            st[i + 15] ^= t; \
   55|  3.81M|            st[i + 20] ^= t; \
   56|  3.81M|        }
   57|       |
   58|  3.81M|        THETA(0);
  ------------------
  |  |   49|  3.81M|#define THETA(i) { \
  |  |   50|  3.81M|            t = bc[(i + 4) % 5] ^ ROTL64(bc[(i + 1) % 5], 1); \
  |  |  ------------------
  |  |  |  |   15|  3.81M|#define ROTL64(x, y) (((x) << (y)) | ((x) >> (64 - (y))))
  |  |  ------------------
  |  |   51|  3.81M|            st[i     ] ^= t; \
  |  |   52|  3.81M|            st[i +  5] ^= t; \
  |  |   53|  3.81M|            st[i + 10] ^= t; \
  |  |   54|  3.81M|            st[i + 15] ^= t; \
  |  |   55|  3.81M|            st[i + 20] ^= t; \
  |  |   56|  3.81M|        }
  ------------------
   59|  3.81M|        THETA(1);
  ------------------
  |  |   49|  3.81M|#define THETA(i) { \
  |  |   50|  3.81M|            t = bc[(i + 4) % 5] ^ ROTL64(bc[(i + 1) % 5], 1); \
  |  |  ------------------
  |  |  |  |   15|  3.81M|#define ROTL64(x, y) (((x) << (y)) | ((x) >> (64 - (y))))
  |  |  ------------------
  |  |   51|  3.81M|            st[i     ] ^= t; \
  |  |   52|  3.81M|            st[i +  5] ^= t; \
  |  |   53|  3.81M|            st[i + 10] ^= t; \
  |  |   54|  3.81M|            st[i + 15] ^= t; \
  |  |   55|  3.81M|            st[i + 20] ^= t; \
  |  |   56|  3.81M|        }
  ------------------
   60|  3.81M|        THETA(2);
  ------------------
  |  |   49|  3.81M|#define THETA(i) { \
  |  |   50|  3.81M|            t = bc[(i + 4) % 5] ^ ROTL64(bc[(i + 1) % 5], 1); \
  |  |  ------------------
  |  |  |  |   15|  3.81M|#define ROTL64(x, y) (((x) << (y)) | ((x) >> (64 - (y))))
  |  |  ------------------
  |  |   51|  3.81M|            st[i     ] ^= t; \
  |  |   52|  3.81M|            st[i +  5] ^= t; \
  |  |   53|  3.81M|            st[i + 10] ^= t; \
  |  |   54|  3.81M|            st[i + 15] ^= t; \
  |  |   55|  3.81M|            st[i + 20] ^= t; \
  |  |   56|  3.81M|        }
  ------------------
   61|  3.81M|        THETA(3);
  ------------------
  |  |   49|  3.81M|#define THETA(i) { \
  |  |   50|  3.81M|            t = bc[(i + 4) % 5] ^ ROTL64(bc[(i + 1) % 5], 1); \
  |  |  ------------------
  |  |  |  |   15|  3.81M|#define ROTL64(x, y) (((x) << (y)) | ((x) >> (64 - (y))))
  |  |  ------------------
  |  |   51|  3.81M|            st[i     ] ^= t; \
  |  |   52|  3.81M|            st[i +  5] ^= t; \
  |  |   53|  3.81M|            st[i + 10] ^= t; \
  |  |   54|  3.81M|            st[i + 15] ^= t; \
  |  |   55|  3.81M|            st[i + 20] ^= t; \
  |  |   56|  3.81M|        }
  ------------------
   62|  3.81M|        THETA(4);
  ------------------
  |  |   49|  3.81M|#define THETA(i) { \
  |  |   50|  3.81M|            t = bc[(i + 4) % 5] ^ ROTL64(bc[(i + 1) % 5], 1); \
  |  |  ------------------
  |  |  |  |   15|  3.81M|#define ROTL64(x, y) (((x) << (y)) | ((x) >> (64 - (y))))
  |  |  ------------------
  |  |   51|  3.81M|            st[i     ] ^= t; \
  |  |   52|  3.81M|            st[i +  5] ^= t; \
  |  |   53|  3.81M|            st[i + 10] ^= t; \
  |  |   54|  3.81M|            st[i + 15] ^= t; \
  |  |   55|  3.81M|            st[i + 20] ^= t; \
  |  |   56|  3.81M|        }
  ------------------
   63|       |
   64|       |        // Rho Pi
   65|  3.81M|        t = st[1];
   66|  3.81M|        st[ 1] = ROTL64(st[ 6], 44);
  ------------------
  |  |   15|  3.81M|#define ROTL64(x, y) (((x) << (y)) | ((x) >> (64 - (y))))
  ------------------
   67|  3.81M|        st[ 6] = ROTL64(st[ 9], 20);
  ------------------
  |  |   15|  3.81M|#define ROTL64(x, y) (((x) << (y)) | ((x) >> (64 - (y))))
  ------------------
   68|  3.81M|        st[ 9] = ROTL64(st[22], 61);
  ------------------
  |  |   15|  3.81M|#define ROTL64(x, y) (((x) << (y)) | ((x) >> (64 - (y))))
  ------------------
   69|  3.81M|        st[22] = ROTL64(st[14], 39);
  ------------------
  |  |   15|  3.81M|#define ROTL64(x, y) (((x) << (y)) | ((x) >> (64 - (y))))
  ------------------
   70|  3.81M|        st[14] = ROTL64(st[20], 18);
  ------------------
  |  |   15|  3.81M|#define ROTL64(x, y) (((x) << (y)) | ((x) >> (64 - (y))))
  ------------------
   71|  3.81M|        st[20] = ROTL64(st[ 2], 62);
  ------------------
  |  |   15|  3.81M|#define ROTL64(x, y) (((x) << (y)) | ((x) >> (64 - (y))))
  ------------------
   72|  3.81M|        st[ 2] = ROTL64(st[12], 43);
  ------------------
  |  |   15|  3.81M|#define ROTL64(x, y) (((x) << (y)) | ((x) >> (64 - (y))))
  ------------------
   73|  3.81M|        st[12] = ROTL64(st[13], 25);
  ------------------
  |  |   15|  3.81M|#define ROTL64(x, y) (((x) << (y)) | ((x) >> (64 - (y))))
  ------------------
   74|  3.81M|        st[13] = ROTL64(st[19],  8);
  ------------------
  |  |   15|  3.81M|#define ROTL64(x, y) (((x) << (y)) | ((x) >> (64 - (y))))
  ------------------
   75|  3.81M|        st[19] = ROTL64(st[23], 56);
  ------------------
  |  |   15|  3.81M|#define ROTL64(x, y) (((x) << (y)) | ((x) >> (64 - (y))))
  ------------------
   76|  3.81M|        st[23] = ROTL64(st[15], 41);
  ------------------
  |  |   15|  3.81M|#define ROTL64(x, y) (((x) << (y)) | ((x) >> (64 - (y))))
  ------------------
   77|  3.81M|        st[15] = ROTL64(st[ 4], 27);
  ------------------
  |  |   15|  3.81M|#define ROTL64(x, y) (((x) << (y)) | ((x) >> (64 - (y))))
  ------------------
   78|  3.81M|        st[ 4] = ROTL64(st[24], 14);
  ------------------
  |  |   15|  3.81M|#define ROTL64(x, y) (((x) << (y)) | ((x) >> (64 - (y))))
  ------------------
   79|  3.81M|        st[24] = ROTL64(st[21],  2);
  ------------------
  |  |   15|  3.81M|#define ROTL64(x, y) (((x) << (y)) | ((x) >> (64 - (y))))
  ------------------
   80|  3.81M|        st[21] = ROTL64(st[ 8], 55);
  ------------------
  |  |   15|  3.81M|#define ROTL64(x, y) (((x) << (y)) | ((x) >> (64 - (y))))
  ------------------
   81|  3.81M|        st[ 8] = ROTL64(st[16], 45);
  ------------------
  |  |   15|  3.81M|#define ROTL64(x, y) (((x) << (y)) | ((x) >> (64 - (y))))
  ------------------
   82|  3.81M|        st[16] = ROTL64(st[ 5], 36);
  ------------------
  |  |   15|  3.81M|#define ROTL64(x, y) (((x) << (y)) | ((x) >> (64 - (y))))
  ------------------
   83|  3.81M|        st[ 5] = ROTL64(st[ 3], 28);
  ------------------
  |  |   15|  3.81M|#define ROTL64(x, y) (((x) << (y)) | ((x) >> (64 - (y))))
  ------------------
   84|  3.81M|        st[ 3] = ROTL64(st[18], 21);
  ------------------
  |  |   15|  3.81M|#define ROTL64(x, y) (((x) << (y)) | ((x) >> (64 - (y))))
  ------------------
   85|  3.81M|        st[18] = ROTL64(st[17], 15);
  ------------------
  |  |   15|  3.81M|#define ROTL64(x, y) (((x) << (y)) | ((x) >> (64 - (y))))
  ------------------
   86|  3.81M|        st[17] = ROTL64(st[11], 10);
  ------------------
  |  |   15|  3.81M|#define ROTL64(x, y) (((x) << (y)) | ((x) >> (64 - (y))))
  ------------------
   87|  3.81M|        st[11] = ROTL64(st[ 7],  6);
  ------------------
  |  |   15|  3.81M|#define ROTL64(x, y) (((x) << (y)) | ((x) >> (64 - (y))))
  ------------------
   88|  3.81M|        st[ 7] = ROTL64(st[10],  3);
  ------------------
  |  |   15|  3.81M|#define ROTL64(x, y) (((x) << (y)) | ((x) >> (64 - (y))))
  ------------------
   89|  3.81M|        st[10] = ROTL64(t, 1);
  ------------------
  |  |   15|  3.81M|#define ROTL64(x, y) (((x) << (y)) | ((x) >> (64 - (y))))
  ------------------
   90|       |
   91|       |        //  Chi
   92|  3.81M|#define CHI(j) { \
   93|  3.81M|            const uint64_t st0 = st[j    ]; \
   94|  3.81M|            const uint64_t st1 = st[j + 1]; \
   95|  3.81M|            const uint64_t st2 = st[j + 2]; \
   96|  3.81M|            const uint64_t st3 = st[j + 3]; \
   97|  3.81M|            const uint64_t st4 = st[j + 4]; \
   98|  3.81M|            st[j    ] ^= ~st1 & st2; \
   99|  3.81M|            st[j + 1] ^= ~st2 & st3; \
  100|  3.81M|            st[j + 2] ^= ~st3 & st4; \
  101|  3.81M|            st[j + 3] ^= ~st4 & st0; \
  102|  3.81M|            st[j + 4] ^= ~st0 & st1; \
  103|  3.81M|        }
  104|       |
  105|  3.81M|        CHI( 0);
  ------------------
  |  |   92|  3.81M|#define CHI(j) { \
  |  |   93|  3.81M|            const uint64_t st0 = st[j    ]; \
  |  |   94|  3.81M|            const uint64_t st1 = st[j + 1]; \
  |  |   95|  3.81M|            const uint64_t st2 = st[j + 2]; \
  |  |   96|  3.81M|            const uint64_t st3 = st[j + 3]; \
  |  |   97|  3.81M|            const uint64_t st4 = st[j + 4]; \
  |  |   98|  3.81M|            st[j    ] ^= ~st1 & st2; \
  |  |   99|  3.81M|            st[j + 1] ^= ~st2 & st3; \
  |  |  100|  3.81M|            st[j + 2] ^= ~st3 & st4; \
  |  |  101|  3.81M|            st[j + 3] ^= ~st4 & st0; \
  |  |  102|  3.81M|            st[j + 4] ^= ~st0 & st1; \
  |  |  103|  3.81M|        }
  ------------------
  106|  3.81M|        CHI( 5);
  ------------------
  |  |   92|  3.81M|#define CHI(j) { \
  |  |   93|  3.81M|            const uint64_t st0 = st[j    ]; \
  |  |   94|  3.81M|            const uint64_t st1 = st[j + 1]; \
  |  |   95|  3.81M|            const uint64_t st2 = st[j + 2]; \
  |  |   96|  3.81M|            const uint64_t st3 = st[j + 3]; \
  |  |   97|  3.81M|            const uint64_t st4 = st[j + 4]; \
  |  |   98|  3.81M|            st[j    ] ^= ~st1 & st2; \
  |  |   99|  3.81M|            st[j + 1] ^= ~st2 & st3; \
  |  |  100|  3.81M|            st[j + 2] ^= ~st3 & st4; \
  |  |  101|  3.81M|            st[j + 3] ^= ~st4 & st0; \
  |  |  102|  3.81M|            st[j + 4] ^= ~st0 & st1; \
  |  |  103|  3.81M|        }
  ------------------
  107|  3.81M|        CHI(10);
  ------------------
  |  |   92|  3.81M|#define CHI(j) { \
  |  |   93|  3.81M|            const uint64_t st0 = st[j    ]; \
  |  |   94|  3.81M|            const uint64_t st1 = st[j + 1]; \
  |  |   95|  3.81M|            const uint64_t st2 = st[j + 2]; \
  |  |   96|  3.81M|            const uint64_t st3 = st[j + 3]; \
  |  |   97|  3.81M|            const uint64_t st4 = st[j + 4]; \
  |  |   98|  3.81M|            st[j    ] ^= ~st1 & st2; \
  |  |   99|  3.81M|            st[j + 1] ^= ~st2 & st3; \
  |  |  100|  3.81M|            st[j + 2] ^= ~st3 & st4; \
  |  |  101|  3.81M|            st[j + 3] ^= ~st4 & st0; \
  |  |  102|  3.81M|            st[j + 4] ^= ~st0 & st1; \
  |  |  103|  3.81M|        }
  ------------------
  108|  3.81M|        CHI(15);
  ------------------
  |  |   92|  3.81M|#define CHI(j) { \
  |  |   93|  3.81M|            const uint64_t st0 = st[j    ]; \
  |  |   94|  3.81M|            const uint64_t st1 = st[j + 1]; \
  |  |   95|  3.81M|            const uint64_t st2 = st[j + 2]; \
  |  |   96|  3.81M|            const uint64_t st3 = st[j + 3]; \
  |  |   97|  3.81M|            const uint64_t st4 = st[j + 4]; \
  |  |   98|  3.81M|            st[j    ] ^= ~st1 & st2; \
  |  |   99|  3.81M|            st[j + 1] ^= ~st2 & st3; \
  |  |  100|  3.81M|            st[j + 2] ^= ~st3 & st4; \
  |  |  101|  3.81M|            st[j + 3] ^= ~st4 & st0; \
  |  |  102|  3.81M|            st[j + 4] ^= ~st0 & st1; \
  |  |  103|  3.81M|        }
  ------------------
  109|  3.81M|        CHI(20);
  ------------------
  |  |   92|  3.81M|#define CHI(j) { \
  |  |   93|  3.81M|            const uint64_t st0 = st[j    ]; \
  |  |   94|  3.81M|            const uint64_t st1 = st[j + 1]; \
  |  |   95|  3.81M|            const uint64_t st2 = st[j + 2]; \
  |  |   96|  3.81M|            const uint64_t st3 = st[j + 3]; \
  |  |   97|  3.81M|            const uint64_t st4 = st[j + 4]; \
  |  |   98|  3.81M|            st[j    ] ^= ~st1 & st2; \
  |  |   99|  3.81M|            st[j + 1] ^= ~st2 & st3; \
  |  |  100|  3.81M|            st[j + 2] ^= ~st3 & st4; \
  |  |  101|  3.81M|            st[j + 3] ^= ~st4 & st0; \
  |  |  102|  3.81M|            st[j + 4] ^= ~st0 & st1; \
  |  |  103|  3.81M|        }
  ------------------
  110|       |
  111|       |        //  Iota
  112|  3.81M|        st[0] ^= keccakf_rndc[round];
  113|  3.81M|    }
  114|   159k|}
keccak:
  120|  28.4k|{
  121|  28.4k|    state_t st;
  122|  28.4k|    uint8_t temp[144];
  123|  28.4k|    size_t i, rsiz, rsizw;
  124|       |
  125|  28.4k|    static_assert(HASH_DATA_AREA <= sizeof(temp), "Bad keccak preconditions");
  126|  28.4k|    if (mdlen <= 0 || (mdlen >= 100 && sizeof(st) != (size_t)mdlen))
  ------------------
  |  Branch (126:9): [True: 0, False: 28.4k]
  |  Branch (126:24): [True: 28.4k, False: 1]
  |  Branch (126:40): [True: 0, False: 28.4k]
  ------------------
  127|      0|    {
  128|      0|      local_abort("Bad keccak use");
  129|      0|    }
  130|       |
  131|  28.4k|    rsiz = sizeof(state_t) == mdlen ? HASH_DATA_AREA : 200 - 2 * mdlen;
  ------------------
  |  Branch (131:12): [True: 28.4k, False: 1]
  ------------------
  132|  28.4k|    rsizw = rsiz / 8;
  133|       |    
  134|  28.4k|    memset(st, 0, sizeof(st));
  135|       |
  136|  37.0k|    for ( ; inlen >= rsiz; inlen -= rsiz, in += rsiz) {
  ------------------
  |  Branch (136:13): [True: 8.61k, False: 28.4k]
  ------------------
  137|   155k|      for (i = 0; i < rsizw; i++) {
  ------------------
  |  Branch (137:19): [True: 146k, False: 8.61k]
  ------------------
  138|   146k|        uint64_t ina;
  139|   146k|        memcpy(&ina, in + i * 8, 8);
  140|   146k|        st[i] ^= swap64le(ina);
  ------------------
  |  |  287|   146k|#define swap64le ident64
  ------------------
  141|   146k|      }
  142|  8.61k|      keccakf(st, KECCAK_ROUNDS);
  ------------------
  |  |   11|  8.61k|#define KECCAK_ROUNDS 24
  ------------------
  143|  8.61k|    }
  144|       |    
  145|       |    // last block and padding
  146|  28.4k|    if (inlen + 1 >= sizeof(temp) || inlen > rsiz || rsiz - inlen + inlen + 1 >= sizeof(temp) || rsiz == 0 || rsiz - 1 >= sizeof(temp) || rsizw * 8 > sizeof(temp))
  ------------------
  |  Branch (146:9): [True: 0, False: 28.4k]
  |  Branch (146:38): [True: 0, False: 28.4k]
  |  Branch (146:54): [True: 0, False: 28.4k]
  |  Branch (146:98): [True: 0, False: 28.4k]
  |  Branch (146:111): [True: 0, False: 28.4k]
  |  Branch (146:139): [True: 0, False: 28.4k]
  ------------------
  147|      0|    {
  148|      0|      local_abort("Bad keccak use");
  149|      0|    }
  150|       |
  151|  28.4k|    if (inlen > 0)
  ------------------
  |  Branch (151:9): [True: 28.4k, False: 1]
  ------------------
  152|  28.4k|      memcpy(temp, in, inlen);
  153|  28.4k|    temp[inlen++] = 1;
  154|  28.4k|    memset(temp + inlen, 0, rsiz - inlen);
  155|  28.4k|    temp[rsiz - 1] |= 0x80;
  156|       |
  157|   512k|    for (i = 0; i < rsizw; i++)
  ------------------
  |  Branch (157:17): [True: 483k, False: 28.4k]
  ------------------
  158|   483k|        st[i] ^= swap64le(((uint64_t *) temp)[i]);
  ------------------
  |  |  287|   483k|#define swap64le ident64
  ------------------
  159|       |
  160|  28.4k|    keccakf(st, KECCAK_ROUNDS);
  ------------------
  |  |   11|  28.4k|#define KECCAK_ROUNDS 24
  ------------------
  161|       |
  162|  28.4k|    if (((size_t)mdlen % sizeof(uint64_t)) != 0)
  ------------------
  |  Branch (162:9): [True: 0, False: 28.4k]
  ------------------
  163|      0|    {
  164|      0|      local_abort("Bad keccak use");
  165|      0|    }
  166|  28.4k|    memcpy_swap64le(md, st, mdlen/sizeof(uint64_t));
  ------------------
  |  |  291|  28.4k|#define memcpy_swap64le memcpy_ident64
  ------------------
  167|  28.4k|}
keccak1600:
  170|  28.4k|{
  171|  28.4k|    keccak(in, inlen, md, sizeof(state_t));
  172|  28.4k|}

random.c:init_random:
  112|      2|INITIALIZER(init_random) {
  113|      2|  generate_system_random_bytes(32, &state);
  114|      2|  REGISTER_FINALIZER(deinit_random);
  ------------------
  |  |   41|      2|#define REGISTER_FINALIZER(name) ((void) 0)
  ------------------
  115|       |#if !defined(NDEBUG)
  116|       |  assert(curstate == 0);
  117|       |  curstate = 1;
  118|       |#endif
  119|      2|}
generate_random_bytes_not_thread_safe:
  121|   116k|void generate_random_bytes_not_thread_safe(size_t n, void *result) {
  122|       |#if !defined(NDEBUG)
  123|       |  assert(curstate == 1);
  124|       |  curstate = 2;
  125|       |#endif
  126|   116k|  if (n == 0) {
  ------------------
  |  Branch (126:7): [True: 0, False: 116k]
  ------------------
  127|       |#if !defined(NDEBUG)
  128|       |    assert(curstate == 2);
  129|       |    curstate = 1;
  130|       |#endif
  131|      0|    return;
  132|      0|  }
  133|   116k|  for (;;) {
  134|   116k|    hash_permutation(&state);
  135|   116k|    if (n <= HASH_DATA_AREA) {
  ------------------
  |  Branch (135:9): [True: 116k, False: 0]
  ------------------
  136|   116k|      memcpy(result, &state, n);
  137|       |#if !defined(NDEBUG)
  138|       |      assert(curstate == 2);
  139|       |      curstate = 1;
  140|       |#endif
  141|   116k|      return;
  142|   116k|    } else {
  143|      0|      memcpy(result, &state, HASH_DATA_AREA);
  144|      0|      result = padd(result, HASH_DATA_AREA);
  145|      0|      n -= HASH_DATA_AREA;
  146|      0|    }
  147|   116k|  }
  148|   116k|}
random.c:generate_system_random_bytes:
   70|      2|static void generate_system_random_bytes(size_t n, void *result) {
   71|      2|  int fd;
   72|      2|  if ((fd = open("/dev/urandom", O_RDONLY | O_NOCTTY | O_CLOEXEC)) < 0) {
  ------------------
  |  Branch (72:7): [True: 0, False: 2]
  ------------------
   73|      0|    err(EXIT_FAILURE, "open /dev/urandom");
   74|      0|  }
   75|      2|  for (;;) {
   76|      2|    ssize_t res = read(fd, result, n);
   77|      2|    if ((size_t) res == n) {
  ------------------
  |  Branch (77:9): [True: 2, False: 0]
  ------------------
   78|      2|      break;
   79|      2|    }
   80|      0|    if (res < 0) {
  ------------------
  |  Branch (80:9): [True: 0, False: 0]
  ------------------
   81|      0|      if (errno != EINTR) {
  ------------------
  |  Branch (81:11): [True: 0, False: 0]
  ------------------
   82|      0|        err(EXIT_FAILURE, "read /dev/urandom");
   83|      0|      }
   84|      0|    } else if (res == 0) {
  ------------------
  |  Branch (84:16): [True: 0, False: 0]
  ------------------
   85|      0|      errx(EXIT_FAILURE, "read /dev/urandom: end of file");
   86|      0|    } else {
   87|      0|      result = padd(result, (size_t) res);
   88|      0|      n -= (size_t) res;
   89|      0|    }
   90|      0|  }
   91|      2|  if (close(fd) < 0) {
  ------------------
  |  Branch (91:7): [True: 0, False: 2]
  ------------------
   92|      0|    err(EXIT_FAILURE, "close /dev/urandom");
   93|      0|  }
   94|      2|}

cpuid:
  490|      1|{
  491|      1|    ASM __volatile__
  ------------------
  |  |  408|      1|#define ASM __asm__
  ------------------
  492|      1|    (
  493|      1|    "cpuid":
  494|      1|        "=a" (CPUInfo[0]),
  495|      1|        "=b" (CPUInfo[1]),
  496|      1|        "=c" (CPUInfo[2]),
  497|      1|        "=d" (CPUInfo[3]) :
  498|      1|            "a" (InfoType), "c" (0)
  499|      1|        );
  500|      1|}
cn_slow_hash_allocate_state:
  749|      1|{
  750|      1|    if(hp_state != NULL)
  ------------------
  |  Branch (750:8): [True: 0, False: 1]
  ------------------
  751|      0|        return;
  752|       |
  753|       |#if defined(_MSC_VER) || defined(__MINGW32__)
  754|       |    SetLockPagesPrivilege(GetCurrentProcess(), TRUE);
  755|       |    hp_state = (uint8_t *) VirtualAlloc(hp_state, MEMORY, MEM_LARGE_PAGES |
  756|       |                                        MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
  757|       |#else
  758|       |#if defined(__APPLE__) || defined(__FreeBSD__) || defined(__OpenBSD__) || \
  759|       |  defined(__DragonFly__) || defined(__NetBSD__)
  760|       |    hp_state = mmap(0, MEMORY, PROT_READ | PROT_WRITE,
  761|       |                    MAP_PRIVATE | MAP_ANON, -1, 0);
  762|       |#else
  763|      1|    hp_state = mmap(0, MEMORY, PROT_READ | PROT_WRITE,
  ------------------
  |  |   47|      1|#define MEMORY         (1 << 21) // 2MB scratchpad
  ------------------
  764|      1|                    MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB, -1, 0);
  765|      1|#endif
  766|      1|    if(hp_state == MAP_FAILED)
  ------------------
  |  Branch (766:8): [True: 1, False: 0]
  ------------------
  767|      1|        hp_state = NULL;
  768|      1|#endif
  769|      1|    hp_allocated = 1;
  770|      1|    if(hp_state == NULL)
  ------------------
  |  Branch (770:8): [True: 1, False: 0]
  ------------------
  771|      1|    {
  772|      1|        hp_allocated = 0;
  773|      1|        hp_state = (uint8_t *) malloc(MEMORY);
  ------------------
  |  |   47|      1|#define MEMORY         (1 << 21) // 2MB scratchpad
  ------------------
  774|      1|    }
  775|       |
  776|       |
  777|       |#if defined(_MSC_VER) || defined(__MINGW32__)
  778|       |    hp_jitfunc_memory = (uint8_t *) VirtualAlloc(hp_jitfunc_memory, 4096 + 4095,
  779|       |                                                 MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
  780|       |#else
  781|       |#if defined(__APPLE__) || defined(__FreeBSD__) || defined(__OpenBSD__) || \
  782|       |  defined(__DragonFly__) || defined(__NetBSD__)
  783|       |#ifdef __NetBSD__
  784|       |#define RESERVED_FLAGS PROT_MPROTECT(PROT_EXEC)
  785|       |#else
  786|       |#define RESERVED_FLAGS 0
  787|       |#endif
  788|       |    hp_jitfunc_memory = mmap(0, 4096 + 4096, PROT_READ | PROT_WRITE | RESERVED_FLAGS,
  789|       |                    MAP_PRIVATE | MAP_ANON, -1, 0);
  790|       |#else
  791|      1|    hp_jitfunc_memory = mmap(0, 4096 + 4096, PROT_READ | PROT_WRITE | PROT_EXEC,
  792|      1|                    MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
  793|      1|#endif
  794|      1|    if(hp_jitfunc_memory == MAP_FAILED)
  ------------------
  |  Branch (794:8): [True: 0, False: 1]
  ------------------
  795|      0|        hp_jitfunc_memory = NULL;
  796|      1|#endif
  797|      1|    hp_jitfunc_allocated = 1;
  798|      1|    if (hp_jitfunc_memory == NULL)
  ------------------
  |  Branch (798:9): [True: 0, False: 1]
  ------------------
  799|      0|    {
  800|      0|        hp_jitfunc_allocated = 0;
  801|      0|        hp_jitfunc_memory = malloc(4096 + 4095);
  802|      0|    }
  803|      1|    hp_jitfunc = (v4_random_math_JIT_func)((size_t)(hp_jitfunc_memory + 4095) & ~4095);
  804|      1|}
cn_slow_hash:
  875|  5.60k|{
  876|  5.60k|    RDATA_ALIGN16 uint8_t expandedKey[240];  /* These buffers are aligned to use later with SSE functions */
  ------------------
  |  |  401|  5.60k|#define RDATA_ALIGN16 __attribute__ ((aligned(16)))
  ------------------
  877|       |
  878|  5.60k|    uint8_t text[INIT_SIZE_BYTE];
  879|  5.60k|    RDATA_ALIGN16 uint64_t a[2];
  ------------------
  |  |  401|  5.60k|#define RDATA_ALIGN16 __attribute__ ((aligned(16)))
  ------------------
  880|  5.60k|    RDATA_ALIGN16 uint64_t b[4];
  ------------------
  |  |  401|  5.60k|#define RDATA_ALIGN16 __attribute__ ((aligned(16)))
  ------------------
  881|  5.60k|    RDATA_ALIGN16 uint64_t c[2];
  ------------------
  |  |  401|  5.60k|#define RDATA_ALIGN16 __attribute__ ((aligned(16)))
  ------------------
  882|  5.60k|    union cn_slow_hash_state state;
  883|  5.60k|    __m128i _a, _b, _b1, _c;
  884|  5.60k|    uint64_t hi, lo;
  885|       |
  886|  5.60k|    size_t i, j;
  887|  5.60k|    uint64_t *p = NULL;
  888|  5.60k|    oaes_ctx *aes_ctx = NULL;
  889|  5.60k|    int useAes = !force_software_aes() && check_aes_hw();
  ------------------
  |  Branch (889:18): [True: 5.60k, False: 0]
  |  Branch (889:43): [True: 5.60k, False: 0]
  ------------------
  890|       |
  891|  5.60k|    static void (*const extra_hashes[4])(const void *, size_t, char *) =
  892|  5.60k|    {
  893|  5.60k|        hash_extra_blake, hash_extra_groestl, hash_extra_jh, hash_extra_skein
  894|  5.60k|    };
  895|       |
  896|       |    // this isn't supposed to happen, but guard against it for now.
  897|  5.60k|    if(hp_state == NULL)
  ------------------
  |  Branch (897:8): [True: 1, False: 5.60k]
  ------------------
  898|      1|        cn_slow_hash_allocate_state();
  899|       |
  900|       |    // locals to avoid constant TLS dereferencing
  901|  5.60k|    uint8_t *local_hp_state = hp_state;
  902|       |
  903|       |    /* CryptoNight Step 1:  Use Keccak1600 to initialize the 'state' (and 'text') buffers from the data. */
  904|  5.60k|    if (prehashed) {
  ------------------
  |  Branch (904:9): [True: 0, False: 5.60k]
  ------------------
  905|      0|        memcpy(&state.hs, data, length);
  906|  5.60k|    } else {
  907|  5.60k|        hash_process(&state.hs, data, length);
  908|  5.60k|    }
  909|  5.60k|    memcpy(text, state.init, INIT_SIZE_BYTE);
  ------------------
  |  |   52|  5.60k|#define INIT_SIZE_BYTE (INIT_SIZE_BLK * AES_BLOCK_SIZE)
  |  |  ------------------
  |  |  |  |   51|  5.60k|#define INIT_SIZE_BLK   8
  |  |  ------------------
  |  |               #define INIT_SIZE_BYTE (INIT_SIZE_BLK * AES_BLOCK_SIZE)
  |  |  ------------------
  |  |  |  |   49|  5.60k|#define AES_BLOCK_SIZE  16
  |  |  ------------------
  ------------------
  910|       |
  911|  5.60k|    VARIANT1_INIT64();
  ------------------
  |  |  154|  5.60k|  if (variant == 1) \
  |  |  ------------------
  |  |  |  Branch (154:7): [True: 0, False: 5.60k]
  |  |  ------------------
  |  |  155|  5.60k|  { \
  |  |  156|      0|    VARIANT1_CHECK(); \
  |  |  ------------------
  |  |  |  |  136|      0|  do if (length < 43) \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (136:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  137|      0|  { \
  |  |  |  |  138|      0|    fprintf(stderr, "Cryptonight variant 1 needs at least 43 bytes of data"); \
  |  |  |  |  139|      0|    _exit(1); \
  |  |  |  |  140|      0|  } while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (140:11): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  157|      0|  } \
  |  |  158|  5.60k|  const uint64_t tweak1_2 = (variant == 1) ? (state.hs.w[24] ^ (*((const uint64_t*)NONCE_POINTER))) : 0
  |  |  ------------------
  |  |  |  |  142|      0|#define NONCE_POINTER (((const uint8_t*)data)+35)
  |  |  ------------------
  |  |  |  Branch (158:29): [True: 0, False: 5.60k]
  |  |  ------------------
  ------------------
  912|  5.60k|    VARIANT2_INIT64();
  ------------------
  |  |  161|  5.60k|  uint64_t division_result = 0; \
  |  |  162|  5.60k|  uint64_t sqrt_result = 0; \
  |  |  163|  5.60k|  do if (variant >= 2) \
  |  |  ------------------
  |  |  |  Branch (163:10): [True: 0, False: 5.60k]
  |  |  ------------------
  |  |  164|  5.60k|  { \
  |  |  165|      0|    U64(b)[2] = state.hs.w[8] ^ state.hs.w[10]; \
  |  |  ------------------
  |  |  |  |  415|      0|#define U64(x) ((uint64_t *) (x))
  |  |  ------------------
  |  |  166|      0|    U64(b)[3] = state.hs.w[9] ^ state.hs.w[11]; \
  |  |  ------------------
  |  |  |  |  415|      0|#define U64(x) ((uint64_t *) (x))
  |  |  ------------------
  |  |  167|      0|    division_result = SWAP64LE(state.hs.w[12]); \
  |  |  ------------------
  |  |  |  |  285|      0|#define SWAP64LE IDENT64
  |  |  |  |  ------------------
  |  |  |  |  |  |  154|      0|#define IDENT64(x) ((uint64_t) (x))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  168|      0|    sqrt_result = SWAP64LE(state.hs.w[13]); \
  |  |  ------------------
  |  |  |  |  285|      0|#define SWAP64LE IDENT64
  |  |  |  |  ------------------
  |  |  |  |  |  |  154|      0|#define IDENT64(x) ((uint64_t) (x))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  169|  5.60k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (169:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  913|  5.60k|    VARIANT4_RANDOM_MATH_INIT();
  ------------------
  |  |  320|  5.60k|  v4_reg r[9]; \
  |  |  321|  5.60k|  struct V4_Instruction code[NUM_INSTRUCTIONS_MAX + 1]; \
  |  |  322|  5.60k|  int jit = use_v4_jit(); \
  |  |  323|  5.60k|  do if (variant >= 4) \
  |  |  ------------------
  |  |  |  Branch (323:10): [True: 0, False: 5.60k]
  |  |  ------------------
  |  |  324|  5.60k|  { \
  |  |  325|      0|    for (int i = 0; i < 4; ++i) \
  |  |  ------------------
  |  |  |  Branch (325:21): [True: 0, False: 0]
  |  |  ------------------
  |  |  326|      0|      V4_REG_LOAD(r + i, (uint8_t*)(state.hs.w + 12) + sizeof(v4_reg) * i); \
  |  |  ------------------
  |  |  |  |  311|      0|  do { \
  |  |  |  |  312|      0|    memcpy((dst), (src), sizeof(v4_reg)); \
  |  |  |  |  313|      0|    if (sizeof(v4_reg) == sizeof(uint32_t)) \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (313:9): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  |  |  314|      0|      *(dst) = SWAP32LE(*(dst)); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  277|      0|#define SWAP32LE IDENT32
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  153|      0|#define IDENT32(x) ((uint32_t) (x))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  315|      0|    else \
  |  |  |  |  316|      0|      *(dst) = SWAP64LE(*(dst)); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  285|      0|#define SWAP64LE IDENT64
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  154|      0|#define IDENT64(x) ((uint64_t) (x))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  317|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (317:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  327|      0|    v4_random_math_init(code, height); \
  |  |  328|      0|    if (jit) \
  |  |  ------------------
  |  |  |  Branch (328:9): [True: 0, False: 0]
  |  |  ------------------
  |  |  329|      0|    { \
  |  |  330|      0|      int ret = v4_generate_JIT_code(code, hp_jitfunc, 4096); \
  |  |  331|      0|      if (ret < 0) \
  |  |  ------------------
  |  |  |  Branch (331:11): [True: 0, False: 0]
  |  |  ------------------
  |  |  332|      0|        local_abort("Error generating CryptonightR code"); \
  |  |  333|      0|    } \
  |  |  334|  5.60k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (334:12): [Folded - Ignored]
  |  |  ------------------
  ------------------
  914|       |
  915|       |    /* CryptoNight Step 2:  Iteratively encrypt the results from Keccak to fill
  916|       |     * the 2MB large random access buffer.
  917|       |     */
  918|       |
  919|  5.60k|    if(useAes)
  ------------------
  |  Branch (919:8): [True: 5.60k, False: 0]
  ------------------
  920|  5.60k|    {
  921|  5.60k|        aes_expand_key(state.hs.b, expandedKey);
  922|  91.7M|        for(i = 0; i < MEMORY / INIT_SIZE_BYTE; i++)
  ------------------
  |  |   47|  91.7M|#define MEMORY         (1 << 21) // 2MB scratchpad
  ------------------
                      for(i = 0; i < MEMORY / INIT_SIZE_BYTE; i++)
  ------------------
  |  |   52|  91.7M|#define INIT_SIZE_BYTE (INIT_SIZE_BLK * AES_BLOCK_SIZE)
  |  |  ------------------
  |  |  |  |   51|  91.7M|#define INIT_SIZE_BLK   8
  |  |  ------------------
  |  |               #define INIT_SIZE_BYTE (INIT_SIZE_BLK * AES_BLOCK_SIZE)
  |  |  ------------------
  |  |  |  |   49|  91.7M|#define AES_BLOCK_SIZE  16
  |  |  ------------------
  ------------------
  |  Branch (922:20): [True: 91.7M, False: 5.60k]
  ------------------
  923|  91.7M|        {
  924|  91.7M|            aes_pseudo_round(text, text, expandedKey, INIT_SIZE_BLK);
  ------------------
  |  |   51|  91.7M|#define INIT_SIZE_BLK   8
  ------------------
  925|  91.7M|            memcpy(&local_hp_state[i * INIT_SIZE_BYTE], text, INIT_SIZE_BYTE);
  ------------------
  |  |   52|  91.7M|#define INIT_SIZE_BYTE (INIT_SIZE_BLK * AES_BLOCK_SIZE)
  |  |  ------------------
  |  |  |  |   51|  91.7M|#define INIT_SIZE_BLK   8
  |  |  ------------------
  |  |               #define INIT_SIZE_BYTE (INIT_SIZE_BLK * AES_BLOCK_SIZE)
  |  |  ------------------
  |  |  |  |   49|  91.7M|#define AES_BLOCK_SIZE  16
  |  |  ------------------
  ------------------
                          memcpy(&local_hp_state[i * INIT_SIZE_BYTE], text, INIT_SIZE_BYTE);
  ------------------
  |  |   52|  91.7M|#define INIT_SIZE_BYTE (INIT_SIZE_BLK * AES_BLOCK_SIZE)
  |  |  ------------------
  |  |  |  |   51|  91.7M|#define INIT_SIZE_BLK   8
  |  |  ------------------
  |  |               #define INIT_SIZE_BYTE (INIT_SIZE_BLK * AES_BLOCK_SIZE)
  |  |  ------------------
  |  |  |  |   49|  91.7M|#define AES_BLOCK_SIZE  16
  |  |  ------------------
  ------------------
  926|  91.7M|        }
  927|  5.60k|    }
  928|      0|    else
  929|      0|    {
  930|      0|        aes_ctx = (oaes_ctx *) oaes_alloc();
  931|      0|        oaes_key_import_data(aes_ctx, state.hs.b, AES_KEY_SIZE);
  ------------------
  |  |   50|      0|#define AES_KEY_SIZE    32
  ------------------
  932|      0|        for(i = 0; i < MEMORY / INIT_SIZE_BYTE; i++)
  ------------------
  |  |   47|      0|#define MEMORY         (1 << 21) // 2MB scratchpad
  ------------------
                      for(i = 0; i < MEMORY / INIT_SIZE_BYTE; i++)
  ------------------
  |  |   52|      0|#define INIT_SIZE_BYTE (INIT_SIZE_BLK * AES_BLOCK_SIZE)
  |  |  ------------------
  |  |  |  |   51|      0|#define INIT_SIZE_BLK   8
  |  |  ------------------
  |  |               #define INIT_SIZE_BYTE (INIT_SIZE_BLK * AES_BLOCK_SIZE)
  |  |  ------------------
  |  |  |  |   49|      0|#define AES_BLOCK_SIZE  16
  |  |  ------------------
  ------------------
  |  Branch (932:20): [True: 0, False: 0]
  ------------------
  933|      0|        {
  934|      0|            for(j = 0; j < INIT_SIZE_BLK; j++)
  ------------------
  |  |   51|      0|#define INIT_SIZE_BLK   8
  ------------------
  |  Branch (934:24): [True: 0, False: 0]
  ------------------
  935|      0|                aesb_pseudo_round(&text[AES_BLOCK_SIZE * j], &text[AES_BLOCK_SIZE * j], aes_ctx->key->exp_data);
  ------------------
  |  |   49|      0|#define AES_BLOCK_SIZE  16
  ------------------
                              aesb_pseudo_round(&text[AES_BLOCK_SIZE * j], &text[AES_BLOCK_SIZE * j], aes_ctx->key->exp_data);
  ------------------
  |  |   49|      0|#define AES_BLOCK_SIZE  16
  ------------------
  936|       |
  937|      0|            memcpy(&local_hp_state[i * INIT_SIZE_BYTE], text, INIT_SIZE_BYTE);
  ------------------
  |  |   52|      0|#define INIT_SIZE_BYTE (INIT_SIZE_BLK * AES_BLOCK_SIZE)
  |  |  ------------------
  |  |  |  |   51|      0|#define INIT_SIZE_BLK   8
  |  |  ------------------
  |  |               #define INIT_SIZE_BYTE (INIT_SIZE_BLK * AES_BLOCK_SIZE)
  |  |  ------------------
  |  |  |  |   49|      0|#define AES_BLOCK_SIZE  16
  |  |  ------------------
  ------------------
                          memcpy(&local_hp_state[i * INIT_SIZE_BYTE], text, INIT_SIZE_BYTE);
  ------------------
  |  |   52|      0|#define INIT_SIZE_BYTE (INIT_SIZE_BLK * AES_BLOCK_SIZE)
  |  |  ------------------
  |  |  |  |   51|      0|#define INIT_SIZE_BLK   8
  |  |  ------------------
  |  |               #define INIT_SIZE_BYTE (INIT_SIZE_BLK * AES_BLOCK_SIZE)
  |  |  ------------------
  |  |  |  |   49|      0|#define AES_BLOCK_SIZE  16
  |  |  ------------------
  ------------------
  938|      0|        }
  939|      0|    }
  940|       |
  941|  5.60k|    U64(a)[0] = U64(&state.k[0])[0] ^ U64(&state.k[32])[0];
  ------------------
  |  |  415|  5.60k|#define U64(x) ((uint64_t *) (x))
  ------------------
                  U64(a)[0] = U64(&state.k[0])[0] ^ U64(&state.k[32])[0];
  ------------------
  |  |  415|  5.60k|#define U64(x) ((uint64_t *) (x))
  ------------------
                  U64(a)[0] = U64(&state.k[0])[0] ^ U64(&state.k[32])[0];
  ------------------
  |  |  415|  5.60k|#define U64(x) ((uint64_t *) (x))
  ------------------
  942|  5.60k|    U64(a)[1] = U64(&state.k[0])[1] ^ U64(&state.k[32])[1];
  ------------------
  |  |  415|  5.60k|#define U64(x) ((uint64_t *) (x))
  ------------------
                  U64(a)[1] = U64(&state.k[0])[1] ^ U64(&state.k[32])[1];
  ------------------
  |  |  415|  5.60k|#define U64(x) ((uint64_t *) (x))
  ------------------
                  U64(a)[1] = U64(&state.k[0])[1] ^ U64(&state.k[32])[1];
  ------------------
  |  |  415|  5.60k|#define U64(x) ((uint64_t *) (x))
  ------------------
  943|  5.60k|    U64(b)[0] = U64(&state.k[16])[0] ^ U64(&state.k[48])[0];
  ------------------
  |  |  415|  5.60k|#define U64(x) ((uint64_t *) (x))
  ------------------
                  U64(b)[0] = U64(&state.k[16])[0] ^ U64(&state.k[48])[0];
  ------------------
  |  |  415|  5.60k|#define U64(x) ((uint64_t *) (x))
  ------------------
                  U64(b)[0] = U64(&state.k[16])[0] ^ U64(&state.k[48])[0];
  ------------------
  |  |  415|  5.60k|#define U64(x) ((uint64_t *) (x))
  ------------------
  944|  5.60k|    U64(b)[1] = U64(&state.k[16])[1] ^ U64(&state.k[48])[1];
  ------------------
  |  |  415|  5.60k|#define U64(x) ((uint64_t *) (x))
  ------------------
                  U64(b)[1] = U64(&state.k[16])[1] ^ U64(&state.k[48])[1];
  ------------------
  |  |  415|  5.60k|#define U64(x) ((uint64_t *) (x))
  ------------------
                  U64(b)[1] = U64(&state.k[16])[1] ^ U64(&state.k[48])[1];
  ------------------
  |  |  415|  5.60k|#define U64(x) ((uint64_t *) (x))
  ------------------
  945|       |
  946|       |    /* CryptoNight Step 3:  Bounce randomly 1,048,576 times (1<<20) through the mixing buffer,
  947|       |     * using 524,288 iterations of the following mixing function.  Each execution
  948|       |     * performs two reads and writes from the mixing buffer.
  949|       |     */
  950|       |
  951|  5.60k|    _b = _mm_load_si128(R128(b));
  ------------------
  |  |  416|  5.60k|#define R128(x) ((__m128i *) (x))
  ------------------
  952|  5.60k|    _b1 = _mm_load_si128(R128(b) + 1);
  ------------------
  |  |  416|  5.60k|#define R128(x) ((__m128i *) (x))
  ------------------
  953|       |    // Two independent versions, one with AES, one without, to ensure that
  954|       |    // the useAes test is only performed once, not every iteration.
  955|  5.60k|    if(useAes)
  ------------------
  |  Branch (955:8): [True: 5.60k, False: 0]
  ------------------
  956|  5.60k|    {
  957|  2.93G|        for(i = 0; i < ITER / 2; i++)
  ------------------
  |  |   48|  2.93G|#define ITER           (1 << 20)
  ------------------
  |  Branch (957:20): [True: 2.93G, False: 5.60k]
  ------------------
  958|  2.93G|        {
  959|  2.93G|            pre_aes();
  ------------------
  |  |  434|  2.93G|  j = state_index(a); \
  |  |  ------------------
  |  |  |  |  418|  2.93G|#define state_index(x) (((*((uint64_t *)x) >> 4) & (TOTALBLOCKS - 1)) << 4)
  |  |  |  |  ------------------
  |  |  |  |  |  |  413|  2.93G|#define TOTALBLOCKS (MEMORY / AES_BLOCK_SIZE)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   47|  2.93G|#define MEMORY         (1 << 21) // 2MB scratchpad
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               #define TOTALBLOCKS (MEMORY / AES_BLOCK_SIZE)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|  2.93G|#define AES_BLOCK_SIZE  16
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  435|  2.93G|  _c = _mm_load_si128(R128(&local_hp_state[j])); \
  |  |  ------------------
  |  |  |  |  416|  2.93G|#define R128(x) ((__m128i *) (x))
  |  |  ------------------
  |  |  436|  2.93G|  _a = _mm_load_si128(R128(a)); \
  |  |  ------------------
  |  |  |  |  416|  2.93G|#define R128(x) ((__m128i *) (x))
  |  |  ------------------
  ------------------
  960|  2.93G|            _c = _mm_aesenc_si128(_c, _a);
  961|  2.93G|            post_aes();
  ------------------
  |  |  448|  2.93G|  VARIANT2_SHUFFLE_ADD_SSE2(local_hp_state, j); \
  |  |  ------------------
  |  |  |  |  184|  2.93G|  do if (variant >= 2) \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (184:10): [True: 0, False: 2.93G]
  |  |  |  |  ------------------
  |  |  |  |  185|  2.93G|  { \
  |  |  |  |  186|      0|    __m128i chunk1 = _mm_load_si128((__m128i *)((base_ptr) + ((offset) ^ 0x10))); \
  |  |  |  |  187|      0|    const __m128i chunk2 = _mm_load_si128((__m128i *)((base_ptr) + ((offset) ^ 0x20))); \
  |  |  |  |  188|      0|    const __m128i chunk3 = _mm_load_si128((__m128i *)((base_ptr) + ((offset) ^ 0x30))); \
  |  |  |  |  189|      0|    _mm_store_si128((__m128i *)((base_ptr) + ((offset) ^ 0x10)), _mm_add_epi64(chunk3, _b1)); \
  |  |  |  |  190|      0|    _mm_store_si128((__m128i *)((base_ptr) + ((offset) ^ 0x20)), _mm_add_epi64(chunk1, _b)); \
  |  |  |  |  191|      0|    _mm_store_si128((__m128i *)((base_ptr) + ((offset) ^ 0x30)), _mm_add_epi64(chunk2, _a)); \
  |  |  |  |  192|      0|    if (variant >= 4) \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (192:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  193|      0|    { \
  |  |  |  |  194|      0|      chunk1 = _mm_xor_si128(chunk1, chunk2); \
  |  |  |  |  195|      0|      _c = _mm_xor_si128(_c, chunk3); \
  |  |  |  |  196|      0|      _c = _mm_xor_si128(_c, chunk1); \
  |  |  |  |  197|      0|    } \
  |  |  |  |  198|  2.93G|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (198:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  449|  2.93G|  _mm_store_si128(R128(c), _c); \
  |  |  ------------------
  |  |  |  |  416|  2.93G|#define R128(x) ((__m128i *) (x))
  |  |  ------------------
  |  |  450|  2.93G|  _mm_store_si128(R128(&local_hp_state[j]), _mm_xor_si128(_b, _c)); \
  |  |  ------------------
  |  |  |  |  416|  2.93G|#define R128(x) ((__m128i *) (x))
  |  |  ------------------
  |  |  451|  2.93G|  VARIANT1_1(&local_hp_state[j]); \
  |  |  ------------------
  |  |  |  |  121|  2.93G|  do if (variant == 1) \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (121:10): [True: 0, False: 2.93G]
  |  |  |  |  ------------------
  |  |  |  |  122|  2.93G|  { \
  |  |  |  |  123|      0|    const uint8_t tmp = ((const uint8_t*)(p))[11]; \
  |  |  |  |  124|      0|    static const uint32_t table = 0x75310; \
  |  |  |  |  125|      0|    const uint8_t index = (((tmp >> 3) & 6) | (tmp & 1)) << 1; \
  |  |  |  |  126|      0|    ((uint8_t*)(p))[11] = tmp ^ ((table >> index) & 0x30); \
  |  |  |  |  127|  2.93G|  } while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (127:11): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  452|  2.93G|  j = state_index(c); \
  |  |  ------------------
  |  |  |  |  418|  2.93G|#define state_index(x) (((*((uint64_t *)x) >> 4) & (TOTALBLOCKS - 1)) << 4)
  |  |  |  |  ------------------
  |  |  |  |  |  |  413|  2.93G|#define TOTALBLOCKS (MEMORY / AES_BLOCK_SIZE)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   47|  2.93G|#define MEMORY         (1 << 21) // 2MB scratchpad
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               #define TOTALBLOCKS (MEMORY / AES_BLOCK_SIZE)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|  2.93G|#define AES_BLOCK_SIZE  16
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  453|  2.93G|  p = U64(&local_hp_state[j]); \
  |  |  ------------------
  |  |  |  |  415|  2.93G|#define U64(x) ((uint64_t *) (x))
  |  |  ------------------
  |  |  454|  2.93G|  b[0] = p[0]; b[1] = p[1]; \
  |  |  455|  2.93G|  VARIANT2_INTEGER_MATH_SSE2(b, c); \
  |  |  ------------------
  |  |  |  |  268|  2.93G|  do if ((variant == 2) || (variant == 3)) \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (268:10): [True: 0, False: 2.93G]
  |  |  |  |  |  Branch (268:28): [True: 0, False: 2.93G]
  |  |  |  |  ------------------
  |  |  |  |  269|  2.93G|  { \
  |  |  |  |  270|      0|    VARIANT2_INTEGER_MATH_DIVISION_STEP(b, ptr); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  257|      0|  uint64_t tmpx = division_result ^ (sqrt_result << 32); \
  |  |  |  |  |  |  258|      0|  ((uint64_t*)(b))[0] ^= SWAP64LE(tmpx); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  285|      0|#define SWAP64LE IDENT64
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  154|      0|#define IDENT64(x) ((uint64_t) (x))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  259|      0|  { \
  |  |  |  |  |  |  260|      0|    const uint64_t dividend = SWAP64LE(((uint64_t*)(ptr))[1]); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  285|      0|#define SWAP64LE IDENT64
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  154|      0|#define IDENT64(x) ((uint64_t) (x))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  261|      0|    const uint32_t divisor = (SWAP64LE(((uint64_t*)(ptr))[0]) + (uint32_t)(sqrt_result << 1)) | 0x80000001UL; \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  285|      0|#define SWAP64LE IDENT64
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  154|      0|#define IDENT64(x) ((uint64_t) (x))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  262|      0|    division_result = ((uint32_t)(dividend / divisor)) + \
  |  |  |  |  |  |  263|      0|                     (((uint64_t)(dividend % divisor)) << 32); \
  |  |  |  |  |  |  264|      0|  } \
  |  |  |  |  |  |  265|      0|  const uint64_t sqrt_input = SWAP64LE(((uint64_t*)(ptr))[0]) + division_result
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  285|      0|#define SWAP64LE IDENT64
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  154|      0|#define IDENT64(x) ((uint64_t) (x))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  271|      0|    VARIANT2_INTEGER_MATH_SQRT_STEP_SSE2(); \
  |  |  |  |  ------------------
  |  |  |  |  |  |    8|      0|  do { \
  |  |  |  |  |  |    9|      0|    const __m128i exp_double_bias = _mm_set_epi64x(0, 1023ULL << 52); \
  |  |  |  |  |  |   10|      0|    __m128d x = _mm_castsi128_pd(_mm_add_epi64(_mm_cvtsi64_si128(sqrt_input >> 12), exp_double_bias)); \
  |  |  |  |  |  |   11|      0|    x = _mm_sqrt_sd(_mm_setzero_pd(), x); \
  |  |  |  |  |  |   12|      0|    sqrt_result = (uint64_t)(_mm_cvtsi128_si64(_mm_sub_epi64(_mm_castpd_si128(x), exp_double_bias))) >> 19; \
  |  |  |  |  |  |   13|      0|  } while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (13:11): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  272|      0|    VARIANT2_INTEGER_MATH_SQRT_FIXUP(sqrt_result); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  156|      0|  do { \
  |  |  |  |  |  |  157|      0|    const uint64_t s = r >> 1; \
  |  |  |  |  |  |  158|      0|    const uint64_t b = r & 1; \
  |  |  |  |  |  |  159|      0|    const uint64_t r2 = (uint64_t)(s) * (s + b) + (r << 32); \
  |  |  |  |  |  |  160|      0|    r += ((r2 + b > sqrt_input) ? -1 : 0) + ((r2 + (1ULL << 32) < sqrt_input - s) ? 1 : 0); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (160:11): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (160:46): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  161|      0|  } while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (161:11): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  273|  2.93G|  } while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (273:11): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  456|  2.93G|  VARIANT4_RANDOM_MATH(a, b, r, &_b, &_b1); \
  |  |  ------------------
  |  |  |  |  337|  2.93G|  do if (variant >= 4) \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (337:10): [True: 0, False: 2.93G]
  |  |  |  |  ------------------
  |  |  |  |  338|  2.93G|  { \
  |  |  |  |  339|      0|    uint64_t t[2]; \
  |  |  |  |  340|      0|    memcpy(t, b, sizeof(uint64_t)); \
  |  |  |  |  341|      0|    \
  |  |  |  |  342|      0|    if (sizeof(v4_reg) == sizeof(uint32_t)) \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (342:9): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  |  |  343|      0|      t[0] ^= SWAP64LE((r[0] + r[1]) | ((uint64_t)(r[2] + r[3]) << 32)); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  285|      0|#define SWAP64LE IDENT64
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  154|      0|#define IDENT64(x) ((uint64_t) (x))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  344|      0|    else \
  |  |  |  |  345|      0|      t[0] ^= SWAP64LE((r[0] + r[1]) ^ (r[2] + r[3])); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  285|      0|#define SWAP64LE IDENT64
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  154|      0|#define IDENT64(x) ((uint64_t) (x))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  346|      0|    \
  |  |  |  |  347|      0|    memcpy(b, t, sizeof(uint64_t)); \
  |  |  |  |  348|      0|    \
  |  |  |  |  349|      0|    V4_REG_LOAD(r + 4, a); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  311|      0|  do { \
  |  |  |  |  |  |  312|      0|    memcpy((dst), (src), sizeof(v4_reg)); \
  |  |  |  |  |  |  313|      0|    if (sizeof(v4_reg) == sizeof(uint32_t)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (313:9): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  314|      0|      *(dst) = SWAP32LE(*(dst)); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  277|      0|#define SWAP32LE IDENT32
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  153|      0|#define IDENT32(x) ((uint32_t) (x))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  315|      0|    else \
  |  |  |  |  |  |  316|      0|      *(dst) = SWAP64LE(*(dst)); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  285|      0|#define SWAP64LE IDENT64
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  154|      0|#define IDENT64(x) ((uint64_t) (x))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  317|      0|  } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (317:12): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  350|      0|    V4_REG_LOAD(r + 5, (uint64_t*)(a) + 1); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  311|      0|  do { \
  |  |  |  |  |  |  312|      0|    memcpy((dst), (src), sizeof(v4_reg)); \
  |  |  |  |  |  |  313|      0|    if (sizeof(v4_reg) == sizeof(uint32_t)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (313:9): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  314|      0|      *(dst) = SWAP32LE(*(dst)); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  277|      0|#define SWAP32LE IDENT32
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  153|      0|#define IDENT32(x) ((uint32_t) (x))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  315|      0|    else \
  |  |  |  |  |  |  316|      0|      *(dst) = SWAP64LE(*(dst)); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  285|      0|#define SWAP64LE IDENT64
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  154|      0|#define IDENT64(x) ((uint64_t) (x))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  317|      0|  } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (317:12): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  351|      0|    V4_REG_LOAD(r + 6, _b); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  311|      0|  do { \
  |  |  |  |  |  |  312|      0|    memcpy((dst), (src), sizeof(v4_reg)); \
  |  |  |  |  |  |  313|      0|    if (sizeof(v4_reg) == sizeof(uint32_t)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (313:9): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  314|      0|      *(dst) = SWAP32LE(*(dst)); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  277|      0|#define SWAP32LE IDENT32
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  153|      0|#define IDENT32(x) ((uint32_t) (x))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  315|      0|    else \
  |  |  |  |  |  |  316|      0|      *(dst) = SWAP64LE(*(dst)); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  285|      0|#define SWAP64LE IDENT64
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  154|      0|#define IDENT64(x) ((uint64_t) (x))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  317|      0|  } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (317:12): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  352|      0|    V4_REG_LOAD(r + 7, _b1); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  311|      0|  do { \
  |  |  |  |  |  |  312|      0|    memcpy((dst), (src), sizeof(v4_reg)); \
  |  |  |  |  |  |  313|      0|    if (sizeof(v4_reg) == sizeof(uint32_t)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (313:9): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  314|      0|      *(dst) = SWAP32LE(*(dst)); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  277|      0|#define SWAP32LE IDENT32
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  153|      0|#define IDENT32(x) ((uint32_t) (x))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  315|      0|    else \
  |  |  |  |  |  |  316|      0|      *(dst) = SWAP64LE(*(dst)); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  285|      0|#define SWAP64LE IDENT64
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  154|      0|#define IDENT64(x) ((uint64_t) (x))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  317|      0|  } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (317:12): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  353|      0|    V4_REG_LOAD(r + 8, (uint64_t*)(_b1) + 1); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  311|      0|  do { \
  |  |  |  |  |  |  312|      0|    memcpy((dst), (src), sizeof(v4_reg)); \
  |  |  |  |  |  |  313|      0|    if (sizeof(v4_reg) == sizeof(uint32_t)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (313:9): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  314|      0|      *(dst) = SWAP32LE(*(dst)); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  277|      0|#define SWAP32LE IDENT32
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  153|      0|#define IDENT32(x) ((uint32_t) (x))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  315|      0|    else \
  |  |  |  |  |  |  316|      0|      *(dst) = SWAP64LE(*(dst)); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  285|      0|#define SWAP64LE IDENT64
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  154|      0|#define IDENT64(x) ((uint64_t) (x))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  317|      0|  } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (317:12): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  354|      0|    \
  |  |  |  |  355|      0|    if (jit) \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (355:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  356|      0|      (*hp_jitfunc)(r); \
  |  |  |  |  357|      0|    else \
  |  |  |  |  358|      0|      v4_random_math(code, r); \
  |  |  |  |  359|      0|    \
  |  |  |  |  360|      0|    memcpy(t, a, sizeof(uint64_t) * 2); \
  |  |  |  |  361|      0|    \
  |  |  |  |  362|      0|    if (sizeof(v4_reg) == sizeof(uint32_t)) { \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (362:9): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  |  |  363|      0|      t[0] ^= SWAP64LE(r[2] | ((uint64_t)(r[3]) << 32)); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  285|      0|#define SWAP64LE IDENT64
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  154|      0|#define IDENT64(x) ((uint64_t) (x))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  364|      0|      t[1] ^= SWAP64LE(r[0] | ((uint64_t)(r[1]) << 32)); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  285|      0|#define SWAP64LE IDENT64
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  154|      0|#define IDENT64(x) ((uint64_t) (x))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  365|      0|    } else { \
  |  |  |  |  366|      0|      t[0] ^= SWAP64LE(r[2] ^ r[3]); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  285|      0|#define SWAP64LE IDENT64
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  154|      0|#define IDENT64(x) ((uint64_t) (x))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  367|      0|      t[1] ^= SWAP64LE(r[0] ^ r[1]); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  285|      0|#define SWAP64LE IDENT64
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  154|      0|#define IDENT64(x) ((uint64_t) (x))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  368|      0|    } \
  |  |  |  |  369|      0|    memcpy(a, t, sizeof(uint64_t) * 2); \
  |  |  |  |  370|  2.93G|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (370:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  457|  2.93G|  __mul(); \
  |  |  ------------------
  |  |  |  |  427|  2.93G|#define __mul() ASM("mulq %3\n\t" : "=d"(hi), "=a"(lo) : "%a" (c[0]), "rm" (b[0]) : "cc");
  |  |  |  |  ------------------
  |  |  |  |  |  |  408|  2.93G|#define ASM __asm__
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  458|  2.93G|  VARIANT2_2(); \
  |  |  ------------------
  |  |  |  |  302|  2.93G|  do if (variant == 2 || variant == 3) \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (302:10): [True: 0, False: 2.93G]
  |  |  |  |  |  Branch (302:26): [True: 0, False: 2.93G]
  |  |  |  |  ------------------
  |  |  |  |  303|  2.93G|  { \
  |  |  |  |  304|      0|    *U64(local_hp_state + (j ^ 0x10)) ^= SWAP64LE(hi); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  415|      0|#define U64(x) ((uint64_t *) (x))
  |  |  |  |  ------------------
  |  |  |  |                   *U64(local_hp_state + (j ^ 0x10)) ^= SWAP64LE(hi); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  285|      0|#define SWAP64LE IDENT64
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  154|      0|#define IDENT64(x) ((uint64_t) (x))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  305|      0|    *(U64(local_hp_state + (j ^ 0x10)) + 1) ^= SWAP64LE(lo); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  415|      0|#define U64(x) ((uint64_t *) (x))
  |  |  |  |  ------------------
  |  |  |  |                   *(U64(local_hp_state + (j ^ 0x10)) + 1) ^= SWAP64LE(lo); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  285|      0|#define SWAP64LE IDENT64
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  154|      0|#define IDENT64(x) ((uint64_t) (x))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  306|      0|    hi ^= SWAP64LE(*U64(local_hp_state + (j ^ 0x20))); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  285|      0|#define SWAP64LE IDENT64
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  154|      0|#define IDENT64(x) ((uint64_t) (x))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  307|      0|    lo ^= SWAP64LE(*(U64(local_hp_state + (j ^ 0x20)) + 1)); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  285|      0|#define SWAP64LE IDENT64
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  154|      0|#define IDENT64(x) ((uint64_t) (x))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  308|  2.93G|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (308:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  459|  2.93G|  VARIANT2_SHUFFLE_ADD_SSE2(local_hp_state, j); \
  |  |  ------------------
  |  |  |  |  184|  2.93G|  do if (variant >= 2) \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (184:10): [True: 0, False: 2.93G]
  |  |  |  |  ------------------
  |  |  |  |  185|  2.93G|  { \
  |  |  |  |  186|      0|    __m128i chunk1 = _mm_load_si128((__m128i *)((base_ptr) + ((offset) ^ 0x10))); \
  |  |  |  |  187|      0|    const __m128i chunk2 = _mm_load_si128((__m128i *)((base_ptr) + ((offset) ^ 0x20))); \
  |  |  |  |  188|      0|    const __m128i chunk3 = _mm_load_si128((__m128i *)((base_ptr) + ((offset) ^ 0x30))); \
  |  |  |  |  189|      0|    _mm_store_si128((__m128i *)((base_ptr) + ((offset) ^ 0x10)), _mm_add_epi64(chunk3, _b1)); \
  |  |  |  |  190|      0|    _mm_store_si128((__m128i *)((base_ptr) + ((offset) ^ 0x20)), _mm_add_epi64(chunk1, _b)); \
  |  |  |  |  191|      0|    _mm_store_si128((__m128i *)((base_ptr) + ((offset) ^ 0x30)), _mm_add_epi64(chunk2, _a)); \
  |  |  |  |  192|      0|    if (variant >= 4) \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (192:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  193|      0|    { \
  |  |  |  |  194|      0|      chunk1 = _mm_xor_si128(chunk1, chunk2); \
  |  |  |  |  195|      0|      _c = _mm_xor_si128(_c, chunk3); \
  |  |  |  |  196|      0|      _c = _mm_xor_si128(_c, chunk1); \
  |  |  |  |  197|      0|    } \
  |  |  |  |  198|  2.93G|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (198:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  460|  2.93G|  a[0] += hi; a[1] += lo; \
  |  |  461|  2.93G|  p = U64(&local_hp_state[j]); \
  |  |  ------------------
  |  |  |  |  415|  2.93G|#define U64(x) ((uint64_t *) (x))
  |  |  ------------------
  |  |  462|  2.93G|  p[0] = a[0];  p[1] = a[1]; \
  |  |  463|  2.93G|  a[0] ^= b[0]; a[1] ^= b[1]; \
  |  |  464|  2.93G|  VARIANT1_2(p + 1); \
  |  |  ------------------
  |  |  |  |  130|  2.93G|  do if (variant == 1) \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (130:10): [True: 0, False: 2.93G]
  |  |  |  |  ------------------
  |  |  |  |  131|  2.93G|  { \
  |  |  |  |  132|      0|    xor64(p, tweak1_2); \
  |  |  |  |  133|  2.93G|  } while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (133:11): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  465|  2.93G|  _b1 = _b; \
  |  |  466|  2.93G|  _b = _c; \
  ------------------
  962|  2.93G|        }
  963|  5.60k|    }
  964|      0|    else
  965|      0|    {
  966|      0|        for(i = 0; i < ITER / 2; i++)
  ------------------
  |  |   48|      0|#define ITER           (1 << 20)
  ------------------
  |  Branch (966:20): [True: 0, False: 0]
  ------------------
  967|      0|        {
  968|      0|            pre_aes();
  ------------------
  |  |  434|      0|  j = state_index(a); \
  |  |  ------------------
  |  |  |  |  418|      0|#define state_index(x) (((*((uint64_t *)x) >> 4) & (TOTALBLOCKS - 1)) << 4)
  |  |  |  |  ------------------
  |  |  |  |  |  |  413|      0|#define TOTALBLOCKS (MEMORY / AES_BLOCK_SIZE)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   47|      0|#define MEMORY         (1 << 21) // 2MB scratchpad
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               #define TOTALBLOCKS (MEMORY / AES_BLOCK_SIZE)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      0|#define AES_BLOCK_SIZE  16
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  435|      0|  _c = _mm_load_si128(R128(&local_hp_state[j])); \
  |  |  ------------------
  |  |  |  |  416|      0|#define R128(x) ((__m128i *) (x))
  |  |  ------------------
  |  |  436|      0|  _a = _mm_load_si128(R128(a)); \
  |  |  ------------------
  |  |  |  |  416|      0|#define R128(x) ((__m128i *) (x))
  |  |  ------------------
  ------------------
  969|      0|            aesb_single_round((uint8_t *) &_c, (uint8_t *) &_c, (uint8_t *) &_a);
  970|      0|            post_aes();
  ------------------
  |  |  448|      0|  VARIANT2_SHUFFLE_ADD_SSE2(local_hp_state, j); \
  |  |  ------------------
  |  |  |  |  184|      0|  do if (variant >= 2) \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (184:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  185|      0|  { \
  |  |  |  |  186|      0|    __m128i chunk1 = _mm_load_si128((__m128i *)((base_ptr) + ((offset) ^ 0x10))); \
  |  |  |  |  187|      0|    const __m128i chunk2 = _mm_load_si128((__m128i *)((base_ptr) + ((offset) ^ 0x20))); \
  |  |  |  |  188|      0|    const __m128i chunk3 = _mm_load_si128((__m128i *)((base_ptr) + ((offset) ^ 0x30))); \
  |  |  |  |  189|      0|    _mm_store_si128((__m128i *)((base_ptr) + ((offset) ^ 0x10)), _mm_add_epi64(chunk3, _b1)); \
  |  |  |  |  190|      0|    _mm_store_si128((__m128i *)((base_ptr) + ((offset) ^ 0x20)), _mm_add_epi64(chunk1, _b)); \
  |  |  |  |  191|      0|    _mm_store_si128((__m128i *)((base_ptr) + ((offset) ^ 0x30)), _mm_add_epi64(chunk2, _a)); \
  |  |  |  |  192|      0|    if (variant >= 4) \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (192:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  193|      0|    { \
  |  |  |  |  194|      0|      chunk1 = _mm_xor_si128(chunk1, chunk2); \
  |  |  |  |  195|      0|      _c = _mm_xor_si128(_c, chunk3); \
  |  |  |  |  196|      0|      _c = _mm_xor_si128(_c, chunk1); \
  |  |  |  |  197|      0|    } \
  |  |  |  |  198|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (198:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  449|      0|  _mm_store_si128(R128(c), _c); \
  |  |  ------------------
  |  |  |  |  416|      0|#define R128(x) ((__m128i *) (x))
  |  |  ------------------
  |  |  450|      0|  _mm_store_si128(R128(&local_hp_state[j]), _mm_xor_si128(_b, _c)); \
  |  |  ------------------
  |  |  |  |  416|      0|#define R128(x) ((__m128i *) (x))
  |  |  ------------------
  |  |  451|      0|  VARIANT1_1(&local_hp_state[j]); \
  |  |  ------------------
  |  |  |  |  121|      0|  do if (variant == 1) \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (121:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  122|      0|  { \
  |  |  |  |  123|      0|    const uint8_t tmp = ((const uint8_t*)(p))[11]; \
  |  |  |  |  124|      0|    static const uint32_t table = 0x75310; \
  |  |  |  |  125|      0|    const uint8_t index = (((tmp >> 3) & 6) | (tmp & 1)) << 1; \
  |  |  |  |  126|      0|    ((uint8_t*)(p))[11] = tmp ^ ((table >> index) & 0x30); \
  |  |  |  |  127|      0|  } while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (127:11): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  452|      0|  j = state_index(c); \
  |  |  ------------------
  |  |  |  |  418|      0|#define state_index(x) (((*((uint64_t *)x) >> 4) & (TOTALBLOCKS - 1)) << 4)
  |  |  |  |  ------------------
  |  |  |  |  |  |  413|      0|#define TOTALBLOCKS (MEMORY / AES_BLOCK_SIZE)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   47|      0|#define MEMORY         (1 << 21) // 2MB scratchpad
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               #define TOTALBLOCKS (MEMORY / AES_BLOCK_SIZE)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      0|#define AES_BLOCK_SIZE  16
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  453|      0|  p = U64(&local_hp_state[j]); \
  |  |  ------------------
  |  |  |  |  415|      0|#define U64(x) ((uint64_t *) (x))
  |  |  ------------------
  |  |  454|      0|  b[0] = p[0]; b[1] = p[1]; \
  |  |  455|      0|  VARIANT2_INTEGER_MATH_SSE2(b, c); \
  |  |  ------------------
  |  |  |  |  268|      0|  do if ((variant == 2) || (variant == 3)) \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (268:10): [True: 0, False: 0]
  |  |  |  |  |  Branch (268:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  269|      0|  { \
  |  |  |  |  270|      0|    VARIANT2_INTEGER_MATH_DIVISION_STEP(b, ptr); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  257|      0|  uint64_t tmpx = division_result ^ (sqrt_result << 32); \
  |  |  |  |  |  |  258|      0|  ((uint64_t*)(b))[0] ^= SWAP64LE(tmpx); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  285|      0|#define SWAP64LE IDENT64
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  154|      0|#define IDENT64(x) ((uint64_t) (x))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  259|      0|  { \
  |  |  |  |  |  |  260|      0|    const uint64_t dividend = SWAP64LE(((uint64_t*)(ptr))[1]); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  285|      0|#define SWAP64LE IDENT64
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  154|      0|#define IDENT64(x) ((uint64_t) (x))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  261|      0|    const uint32_t divisor = (SWAP64LE(((uint64_t*)(ptr))[0]) + (uint32_t)(sqrt_result << 1)) | 0x80000001UL; \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  285|      0|#define SWAP64LE IDENT64
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  154|      0|#define IDENT64(x) ((uint64_t) (x))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  262|      0|    division_result = ((uint32_t)(dividend / divisor)) + \
  |  |  |  |  |  |  263|      0|                     (((uint64_t)(dividend % divisor)) << 32); \
  |  |  |  |  |  |  264|      0|  } \
  |  |  |  |  |  |  265|      0|  const uint64_t sqrt_input = SWAP64LE(((uint64_t*)(ptr))[0]) + division_result
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  285|      0|#define SWAP64LE IDENT64
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  154|      0|#define IDENT64(x) ((uint64_t) (x))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  271|      0|    VARIANT2_INTEGER_MATH_SQRT_STEP_SSE2(); \
  |  |  |  |  ------------------
  |  |  |  |  |  |    8|      0|  do { \
  |  |  |  |  |  |    9|      0|    const __m128i exp_double_bias = _mm_set_epi64x(0, 1023ULL << 52); \
  |  |  |  |  |  |   10|      0|    __m128d x = _mm_castsi128_pd(_mm_add_epi64(_mm_cvtsi64_si128(sqrt_input >> 12), exp_double_bias)); \
  |  |  |  |  |  |   11|      0|    x = _mm_sqrt_sd(_mm_setzero_pd(), x); \
  |  |  |  |  |  |   12|      0|    sqrt_result = (uint64_t)(_mm_cvtsi128_si64(_mm_sub_epi64(_mm_castpd_si128(x), exp_double_bias))) >> 19; \
  |  |  |  |  |  |   13|      0|  } while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (13:11): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  272|      0|    VARIANT2_INTEGER_MATH_SQRT_FIXUP(sqrt_result); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  156|      0|  do { \
  |  |  |  |  |  |  157|      0|    const uint64_t s = r >> 1; \
  |  |  |  |  |  |  158|      0|    const uint64_t b = r & 1; \
  |  |  |  |  |  |  159|      0|    const uint64_t r2 = (uint64_t)(s) * (s + b) + (r << 32); \
  |  |  |  |  |  |  160|      0|    r += ((r2 + b > sqrt_input) ? -1 : 0) + ((r2 + (1ULL << 32) < sqrt_input - s) ? 1 : 0); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (160:11): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (160:46): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  161|      0|  } while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (161:11): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  273|      0|  } while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (273:11): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  456|      0|  VARIANT4_RANDOM_MATH(a, b, r, &_b, &_b1); \
  |  |  ------------------
  |  |  |  |  337|      0|  do if (variant >= 4) \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (337:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  338|      0|  { \
  |  |  |  |  339|      0|    uint64_t t[2]; \
  |  |  |  |  340|      0|    memcpy(t, b, sizeof(uint64_t)); \
  |  |  |  |  341|      0|    \
  |  |  |  |  342|      0|    if (sizeof(v4_reg) == sizeof(uint32_t)) \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (342:9): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  |  |  343|      0|      t[0] ^= SWAP64LE((r[0] + r[1]) | ((uint64_t)(r[2] + r[3]) << 32)); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  285|      0|#define SWAP64LE IDENT64
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  154|      0|#define IDENT64(x) ((uint64_t) (x))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  344|      0|    else \
  |  |  |  |  345|      0|      t[0] ^= SWAP64LE((r[0] + r[1]) ^ (r[2] + r[3])); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  285|      0|#define SWAP64LE IDENT64
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  154|      0|#define IDENT64(x) ((uint64_t) (x))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  346|      0|    \
  |  |  |  |  347|      0|    memcpy(b, t, sizeof(uint64_t)); \
  |  |  |  |  348|      0|    \
  |  |  |  |  349|      0|    V4_REG_LOAD(r + 4, a); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  311|      0|  do { \
  |  |  |  |  |  |  312|      0|    memcpy((dst), (src), sizeof(v4_reg)); \
  |  |  |  |  |  |  313|      0|    if (sizeof(v4_reg) == sizeof(uint32_t)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (313:9): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  314|      0|      *(dst) = SWAP32LE(*(dst)); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  277|      0|#define SWAP32LE IDENT32
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  153|      0|#define IDENT32(x) ((uint32_t) (x))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  315|      0|    else \
  |  |  |  |  |  |  316|      0|      *(dst) = SWAP64LE(*(dst)); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  285|      0|#define SWAP64LE IDENT64
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  154|      0|#define IDENT64(x) ((uint64_t) (x))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  317|      0|  } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (317:12): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  350|      0|    V4_REG_LOAD(r + 5, (uint64_t*)(a) + 1); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  311|      0|  do { \
  |  |  |  |  |  |  312|      0|    memcpy((dst), (src), sizeof(v4_reg)); \
  |  |  |  |  |  |  313|      0|    if (sizeof(v4_reg) == sizeof(uint32_t)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (313:9): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  314|      0|      *(dst) = SWAP32LE(*(dst)); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  277|      0|#define SWAP32LE IDENT32
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  153|      0|#define IDENT32(x) ((uint32_t) (x))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  315|      0|    else \
  |  |  |  |  |  |  316|      0|      *(dst) = SWAP64LE(*(dst)); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  285|      0|#define SWAP64LE IDENT64
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  154|      0|#define IDENT64(x) ((uint64_t) (x))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  317|      0|  } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (317:12): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  351|      0|    V4_REG_LOAD(r + 6, _b); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  311|      0|  do { \
  |  |  |  |  |  |  312|      0|    memcpy((dst), (src), sizeof(v4_reg)); \
  |  |  |  |  |  |  313|      0|    if (sizeof(v4_reg) == sizeof(uint32_t)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (313:9): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  314|      0|      *(dst) = SWAP32LE(*(dst)); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  277|      0|#define SWAP32LE IDENT32
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  153|      0|#define IDENT32(x) ((uint32_t) (x))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  315|      0|    else \
  |  |  |  |  |  |  316|      0|      *(dst) = SWAP64LE(*(dst)); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  285|      0|#define SWAP64LE IDENT64
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  154|      0|#define IDENT64(x) ((uint64_t) (x))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  317|      0|  } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (317:12): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  352|      0|    V4_REG_LOAD(r + 7, _b1); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  311|      0|  do { \
  |  |  |  |  |  |  312|      0|    memcpy((dst), (src), sizeof(v4_reg)); \
  |  |  |  |  |  |  313|      0|    if (sizeof(v4_reg) == sizeof(uint32_t)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (313:9): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  314|      0|      *(dst) = SWAP32LE(*(dst)); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  277|      0|#define SWAP32LE IDENT32
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  153|      0|#define IDENT32(x) ((uint32_t) (x))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  315|      0|    else \
  |  |  |  |  |  |  316|      0|      *(dst) = SWAP64LE(*(dst)); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  285|      0|#define SWAP64LE IDENT64
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  154|      0|#define IDENT64(x) ((uint64_t) (x))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  317|      0|  } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (317:12): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  353|      0|    V4_REG_LOAD(r + 8, (uint64_t*)(_b1) + 1); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  311|      0|  do { \
  |  |  |  |  |  |  312|      0|    memcpy((dst), (src), sizeof(v4_reg)); \
  |  |  |  |  |  |  313|      0|    if (sizeof(v4_reg) == sizeof(uint32_t)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (313:9): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  314|      0|      *(dst) = SWAP32LE(*(dst)); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  277|      0|#define SWAP32LE IDENT32
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  153|      0|#define IDENT32(x) ((uint32_t) (x))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  315|      0|    else \
  |  |  |  |  |  |  316|      0|      *(dst) = SWAP64LE(*(dst)); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  285|      0|#define SWAP64LE IDENT64
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  154|      0|#define IDENT64(x) ((uint64_t) (x))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  317|      0|  } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (317:12): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  354|      0|    \
  |  |  |  |  355|      0|    if (jit) \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (355:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  356|      0|      (*hp_jitfunc)(r); \
  |  |  |  |  357|      0|    else \
  |  |  |  |  358|      0|      v4_random_math(code, r); \
  |  |  |  |  359|      0|    \
  |  |  |  |  360|      0|    memcpy(t, a, sizeof(uint64_t) * 2); \
  |  |  |  |  361|      0|    \
  |  |  |  |  362|      0|    if (sizeof(v4_reg) == sizeof(uint32_t)) { \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (362:9): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  |  |  363|      0|      t[0] ^= SWAP64LE(r[2] | ((uint64_t)(r[3]) << 32)); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  285|      0|#define SWAP64LE IDENT64
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  154|      0|#define IDENT64(x) ((uint64_t) (x))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  364|      0|      t[1] ^= SWAP64LE(r[0] | ((uint64_t)(r[1]) << 32)); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  285|      0|#define SWAP64LE IDENT64
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  154|      0|#define IDENT64(x) ((uint64_t) (x))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  365|      0|    } else { \
  |  |  |  |  366|      0|      t[0] ^= SWAP64LE(r[2] ^ r[3]); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  285|      0|#define SWAP64LE IDENT64
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  154|      0|#define IDENT64(x) ((uint64_t) (x))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  367|      0|      t[1] ^= SWAP64LE(r[0] ^ r[1]); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  285|      0|#define SWAP64LE IDENT64
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  154|      0|#define IDENT64(x) ((uint64_t) (x))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  368|      0|    } \
  |  |  |  |  369|      0|    memcpy(a, t, sizeof(uint64_t) * 2); \
  |  |  |  |  370|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (370:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  457|      0|  __mul(); \
  |  |  ------------------
  |  |  |  |  427|      0|#define __mul() ASM("mulq %3\n\t" : "=d"(hi), "=a"(lo) : "%a" (c[0]), "rm" (b[0]) : "cc");
  |  |  |  |  ------------------
  |  |  |  |  |  |  408|      0|#define ASM __asm__
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  458|      0|  VARIANT2_2(); \
  |  |  ------------------
  |  |  |  |  302|      0|  do if (variant == 2 || variant == 3) \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (302:10): [True: 0, False: 0]
  |  |  |  |  |  Branch (302:26): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  303|      0|  { \
  |  |  |  |  304|      0|    *U64(local_hp_state + (j ^ 0x10)) ^= SWAP64LE(hi); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  415|      0|#define U64(x) ((uint64_t *) (x))
  |  |  |  |  ------------------
  |  |  |  |                   *U64(local_hp_state + (j ^ 0x10)) ^= SWAP64LE(hi); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  285|      0|#define SWAP64LE IDENT64
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  154|      0|#define IDENT64(x) ((uint64_t) (x))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  305|      0|    *(U64(local_hp_state + (j ^ 0x10)) + 1) ^= SWAP64LE(lo); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  415|      0|#define U64(x) ((uint64_t *) (x))
  |  |  |  |  ------------------
  |  |  |  |                   *(U64(local_hp_state + (j ^ 0x10)) + 1) ^= SWAP64LE(lo); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  285|      0|#define SWAP64LE IDENT64
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  154|      0|#define IDENT64(x) ((uint64_t) (x))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  306|      0|    hi ^= SWAP64LE(*U64(local_hp_state + (j ^ 0x20))); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  285|      0|#define SWAP64LE IDENT64
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  154|      0|#define IDENT64(x) ((uint64_t) (x))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  307|      0|    lo ^= SWAP64LE(*(U64(local_hp_state + (j ^ 0x20)) + 1)); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  285|      0|#define SWAP64LE IDENT64
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  154|      0|#define IDENT64(x) ((uint64_t) (x))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  308|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (308:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  459|      0|  VARIANT2_SHUFFLE_ADD_SSE2(local_hp_state, j); \
  |  |  ------------------
  |  |  |  |  184|      0|  do if (variant >= 2) \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (184:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  185|      0|  { \
  |  |  |  |  186|      0|    __m128i chunk1 = _mm_load_si128((__m128i *)((base_ptr) + ((offset) ^ 0x10))); \
  |  |  |  |  187|      0|    const __m128i chunk2 = _mm_load_si128((__m128i *)((base_ptr) + ((offset) ^ 0x20))); \
  |  |  |  |  188|      0|    const __m128i chunk3 = _mm_load_si128((__m128i *)((base_ptr) + ((offset) ^ 0x30))); \
  |  |  |  |  189|      0|    _mm_store_si128((__m128i *)((base_ptr) + ((offset) ^ 0x10)), _mm_add_epi64(chunk3, _b1)); \
  |  |  |  |  190|      0|    _mm_store_si128((__m128i *)((base_ptr) + ((offset) ^ 0x20)), _mm_add_epi64(chunk1, _b)); \
  |  |  |  |  191|      0|    _mm_store_si128((__m128i *)((base_ptr) + ((offset) ^ 0x30)), _mm_add_epi64(chunk2, _a)); \
  |  |  |  |  192|      0|    if (variant >= 4) \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (192:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  193|      0|    { \
  |  |  |  |  194|      0|      chunk1 = _mm_xor_si128(chunk1, chunk2); \
  |  |  |  |  195|      0|      _c = _mm_xor_si128(_c, chunk3); \
  |  |  |  |  196|      0|      _c = _mm_xor_si128(_c, chunk1); \
  |  |  |  |  197|      0|    } \
  |  |  |  |  198|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (198:12): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  460|      0|  a[0] += hi; a[1] += lo; \
  |  |  461|      0|  p = U64(&local_hp_state[j]); \
  |  |  ------------------
  |  |  |  |  415|      0|#define U64(x) ((uint64_t *) (x))
  |  |  ------------------
  |  |  462|      0|  p[0] = a[0];  p[1] = a[1]; \
  |  |  463|      0|  a[0] ^= b[0]; a[1] ^= b[1]; \
  |  |  464|      0|  VARIANT1_2(p + 1); \
  |  |  ------------------
  |  |  |  |  130|      0|  do if (variant == 1) \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (130:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  131|      0|  { \
  |  |  |  |  132|      0|    xor64(p, tweak1_2); \
  |  |  |  |  133|      0|  } while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (133:11): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  465|      0|  _b1 = _b; \
  |  |  466|      0|  _b = _c; \
  ------------------
  971|      0|        }
  972|      0|    }
  973|       |
  974|       |    /* CryptoNight Step 4:  Sequentially pass through the mixing buffer and use 10 rounds
  975|       |     * of AES encryption to mix the random data back into the 'text' buffer.  'text'
  976|       |     * was originally created with the output of Keccak1600. */
  977|       |
  978|  5.60k|    memcpy(text, state.init, INIT_SIZE_BYTE);
  ------------------
  |  |   52|  5.60k|#define INIT_SIZE_BYTE (INIT_SIZE_BLK * AES_BLOCK_SIZE)
  |  |  ------------------
  |  |  |  |   51|  5.60k|#define INIT_SIZE_BLK   8
  |  |  ------------------
  |  |               #define INIT_SIZE_BYTE (INIT_SIZE_BLK * AES_BLOCK_SIZE)
  |  |  ------------------
  |  |  |  |   49|  5.60k|#define AES_BLOCK_SIZE  16
  |  |  ------------------
  ------------------
  979|  5.60k|    if(useAes)
  ------------------
  |  Branch (979:8): [True: 5.60k, False: 0]
  ------------------
  980|  5.60k|    {
  981|  5.60k|        aes_expand_key(&state.hs.b[32], expandedKey);
  982|  91.7M|        for(i = 0; i < MEMORY / INIT_SIZE_BYTE; i++)
  ------------------
  |  |   47|  91.7M|#define MEMORY         (1 << 21) // 2MB scratchpad
  ------------------
                      for(i = 0; i < MEMORY / INIT_SIZE_BYTE; i++)
  ------------------
  |  |   52|  91.7M|#define INIT_SIZE_BYTE (INIT_SIZE_BLK * AES_BLOCK_SIZE)
  |  |  ------------------
  |  |  |  |   51|  91.7M|#define INIT_SIZE_BLK   8
  |  |  ------------------
  |  |               #define INIT_SIZE_BYTE (INIT_SIZE_BLK * AES_BLOCK_SIZE)
  |  |  ------------------
  |  |  |  |   49|  91.7M|#define AES_BLOCK_SIZE  16
  |  |  ------------------
  ------------------
  |  Branch (982:20): [True: 91.7M, False: 5.60k]
  ------------------
  983|  91.7M|        {
  984|       |            // add the xor to the pseudo round
  985|  91.7M|            aes_pseudo_round_xor(text, text, expandedKey, &local_hp_state[i * INIT_SIZE_BYTE], INIT_SIZE_BLK);
  ------------------
  |  |   52|  91.7M|#define INIT_SIZE_BYTE (INIT_SIZE_BLK * AES_BLOCK_SIZE)
  |  |  ------------------
  |  |  |  |   51|  91.7M|#define INIT_SIZE_BLK   8
  |  |  ------------------
  |  |               #define INIT_SIZE_BYTE (INIT_SIZE_BLK * AES_BLOCK_SIZE)
  |  |  ------------------
  |  |  |  |   49|  91.7M|#define AES_BLOCK_SIZE  16
  |  |  ------------------
  ------------------
                          aes_pseudo_round_xor(text, text, expandedKey, &local_hp_state[i * INIT_SIZE_BYTE], INIT_SIZE_BLK);
  ------------------
  |  |   51|  91.7M|#define INIT_SIZE_BLK   8
  ------------------
  986|  91.7M|        }
  987|  5.60k|    }
  988|      0|    else
  989|      0|    {
  990|      0|        oaes_key_import_data(aes_ctx, &state.hs.b[32], AES_KEY_SIZE);
  ------------------
  |  |   50|      0|#define AES_KEY_SIZE    32
  ------------------
  991|      0|        for(i = 0; i < MEMORY / INIT_SIZE_BYTE; i++)
  ------------------
  |  |   47|      0|#define MEMORY         (1 << 21) // 2MB scratchpad
  ------------------
                      for(i = 0; i < MEMORY / INIT_SIZE_BYTE; i++)
  ------------------
  |  |   52|      0|#define INIT_SIZE_BYTE (INIT_SIZE_BLK * AES_BLOCK_SIZE)
  |  |  ------------------
  |  |  |  |   51|      0|#define INIT_SIZE_BLK   8
  |  |  ------------------
  |  |               #define INIT_SIZE_BYTE (INIT_SIZE_BLK * AES_BLOCK_SIZE)
  |  |  ------------------
  |  |  |  |   49|      0|#define AES_BLOCK_SIZE  16
  |  |  ------------------
  ------------------
  |  Branch (991:20): [True: 0, False: 0]
  ------------------
  992|      0|        {
  993|      0|            for(j = 0; j < INIT_SIZE_BLK; j++)
  ------------------
  |  |   51|      0|#define INIT_SIZE_BLK   8
  ------------------
  |  Branch (993:24): [True: 0, False: 0]
  ------------------
  994|      0|            {
  995|      0|                xor_blocks(&text[j * AES_BLOCK_SIZE], &local_hp_state[i * INIT_SIZE_BYTE + j * AES_BLOCK_SIZE]);
  ------------------
  |  |   49|      0|#define AES_BLOCK_SIZE  16
  ------------------
                              xor_blocks(&text[j * AES_BLOCK_SIZE], &local_hp_state[i * INIT_SIZE_BYTE + j * AES_BLOCK_SIZE]);
  ------------------
  |  |   52|      0|#define INIT_SIZE_BYTE (INIT_SIZE_BLK * AES_BLOCK_SIZE)
  |  |  ------------------
  |  |  |  |   51|      0|#define INIT_SIZE_BLK   8
  |  |  ------------------
  |  |               #define INIT_SIZE_BYTE (INIT_SIZE_BLK * AES_BLOCK_SIZE)
  |  |  ------------------
  |  |  |  |   49|      0|#define AES_BLOCK_SIZE  16
  |  |  ------------------
  ------------------
                              xor_blocks(&text[j * AES_BLOCK_SIZE], &local_hp_state[i * INIT_SIZE_BYTE + j * AES_BLOCK_SIZE]);
  ------------------
  |  |   49|      0|#define AES_BLOCK_SIZE  16
  ------------------
  996|      0|                aesb_pseudo_round(&text[AES_BLOCK_SIZE * j], &text[AES_BLOCK_SIZE * j], aes_ctx->key->exp_data);
  ------------------
  |  |   49|      0|#define AES_BLOCK_SIZE  16
  ------------------
                              aesb_pseudo_round(&text[AES_BLOCK_SIZE * j], &text[AES_BLOCK_SIZE * j], aes_ctx->key->exp_data);
  ------------------
  |  |   49|      0|#define AES_BLOCK_SIZE  16
  ------------------
  997|      0|            }
  998|      0|        }
  999|      0|        oaes_free((OAES_CTX **) &aes_ctx);
 1000|      0|    }
 1001|       |
 1002|       |    /* CryptoNight Step 5:  Apply Keccak to the state again, and then
 1003|       |     * use the resulting data to select which of four finalizer
 1004|       |     * hash functions to apply to the data (Blake, Groestl, JH, or Skein).
 1005|       |     * Use this hash to squeeze the state array down
 1006|       |     * to the final 256 bit hash output.
 1007|       |     */
 1008|       |
 1009|  5.60k|    memcpy(state.init, text, INIT_SIZE_BYTE);
  ------------------
  |  |   52|  5.60k|#define INIT_SIZE_BYTE (INIT_SIZE_BLK * AES_BLOCK_SIZE)
  |  |  ------------------
  |  |  |  |   51|  5.60k|#define INIT_SIZE_BLK   8
  |  |  ------------------
  |  |               #define INIT_SIZE_BYTE (INIT_SIZE_BLK * AES_BLOCK_SIZE)
  |  |  ------------------
  |  |  |  |   49|  5.60k|#define AES_BLOCK_SIZE  16
  |  |  ------------------
  ------------------
 1010|  5.60k|    hash_permutation(&state.hs);
 1011|  5.60k|    extra_hashes[state.hs.b[0] & 3](&state, 200, hash);
 1012|  5.60k|}
slow-hash.c:force_software_aes:
  100|  5.60k|{
  101|  5.60k|  static int use = -1;
  102|       |
  103|  5.60k|  if (use != -1)
  ------------------
  |  Branch (103:7): [True: 5.60k, False: 1]
  ------------------
  104|  5.60k|    return use;
  105|       |
  106|      1|  const char *env = getenv("MONERO_USE_SOFTWARE_AES");
  107|      1|  if (!env) {
  ------------------
  |  Branch (107:7): [True: 1, False: 0]
  ------------------
  108|      1|    use = 0;
  109|      1|  }
  110|      0|  else if (!strcmp(env, "0") || !strcmp(env, "no")) {
  ------------------
  |  Branch (110:12): [True: 0, False: 0]
  |  Branch (110:33): [True: 0, False: 0]
  ------------------
  111|      0|    use = 0;
  112|      0|  }
  113|      0|  else {
  114|      0|    use = 1;
  115|      0|  }
  116|      1|  return use;
  117|  5.60k|}
slow-hash.c:check_aes_hw:
  525|  5.60k|{
  526|  5.60k|    int cpuid_results[4];
  527|  5.60k|    static int supported = -1;
  528|       |
  529|  5.60k|    if(supported >= 0)
  ------------------
  |  Branch (529:8): [True: 5.60k, False: 1]
  ------------------
  530|  5.60k|        return supported;
  531|       |
  532|      1|    cpuid(cpuid_results,1);
  533|      1|    return supported = cpuid_results[2] & (1 << 25);
  534|  5.60k|}
slow-hash.c:use_v4_jit:
   76|  5.60k|{
   77|  5.60k|#if defined(__x86_64__)
   78|       |
   79|  5.60k|  if (use_v4_jit_flag != -1)
  ------------------
  |  Branch (79:7): [True: 5.60k, False: 1]
  ------------------
   80|  5.60k|    return use_v4_jit_flag;
   81|       |
   82|      1|  const char *env = getenv("MONERO_USE_CNV4_JIT");
   83|      1|  if (!env) {
  ------------------
  |  Branch (83:7): [True: 1, False: 0]
  ------------------
   84|      1|    use_v4_jit_flag = 1;
   85|      1|  }
   86|      0|  else if (!strcmp(env, "0") || !strcmp(env, "no")) {
  ------------------
  |  Branch (86:12): [True: 0, False: 0]
  |  Branch (86:33): [True: 0, False: 0]
  ------------------
   87|      0|    use_v4_jit_flag = 0;
   88|      0|  }
   89|      0|  else {
   90|      0|    use_v4_jit_flag = 1;
   91|      0|  }
   92|      1|  return use_v4_jit_flag;
   93|       |#else
   94|       |  return 0;
   95|       |#endif
   96|  5.60k|}
slow-hash.c:aes_expand_key:
  583|  11.2k|{
  584|  11.2k|    __m128i *ek = R128(expandedKey);
  ------------------
  |  |  416|  11.2k|#define R128(x) ((__m128i *) (x))
  ------------------
  585|  11.2k|    __m128i t1, t2, t3;
  586|       |
  587|  11.2k|    t1 = _mm_loadu_si128(R128(key));
  ------------------
  |  |  416|  11.2k|#define R128(x) ((__m128i *) (x))
  ------------------
  588|  11.2k|    t3 = _mm_loadu_si128(R128(key + 16));
  ------------------
  |  |  416|  11.2k|#define R128(x) ((__m128i *) (x))
  ------------------
  589|       |
  590|  11.2k|    ek[0] = t1;
  591|  11.2k|    ek[1] = t3;
  592|       |
  593|  11.2k|    t2 = _mm_aeskeygenassist_si128(t3, 0x01);
  594|  11.2k|    aes_256_assist1(&t1, &t2);
  595|  11.2k|    ek[2] = t1;
  596|  11.2k|    aes_256_assist2(&t1, &t3);
  597|  11.2k|    ek[3] = t3;
  598|       |
  599|  11.2k|    t2 = _mm_aeskeygenassist_si128(t3, 0x02);
  600|  11.2k|    aes_256_assist1(&t1, &t2);
  601|  11.2k|    ek[4] = t1;
  602|  11.2k|    aes_256_assist2(&t1, &t3);
  603|  11.2k|    ek[5] = t3;
  604|       |
  605|  11.2k|    t2 = _mm_aeskeygenassist_si128(t3, 0x04);
  606|  11.2k|    aes_256_assist1(&t1, &t2);
  607|  11.2k|    ek[6] = t1;
  608|  11.2k|    aes_256_assist2(&t1, &t3);
  609|  11.2k|    ek[7] = t3;
  610|       |
  611|  11.2k|    t2 = _mm_aeskeygenassist_si128(t3, 0x08);
  612|  11.2k|    aes_256_assist1(&t1, &t2);
  613|  11.2k|    ek[8] = t1;
  614|  11.2k|    aes_256_assist2(&t1, &t3);
  615|  11.2k|    ek[9] = t3;
  616|       |
  617|  11.2k|    t2 = _mm_aeskeygenassist_si128(t3, 0x10);
  618|  11.2k|    aes_256_assist1(&t1, &t2);
  619|  11.2k|    ek[10] = t1;
  620|  11.2k|}
slow-hash.c:aes_256_assist1:
  537|  56.0k|{
  538|  56.0k|    __m128i t4;
  539|  56.0k|    *t2 = _mm_shuffle_epi32(*t2, 0xff);
  540|  56.0k|    t4 = _mm_slli_si128(*t1, 0x04);
  541|  56.0k|    *t1 = _mm_xor_si128(*t1, t4);
  542|  56.0k|    t4 = _mm_slli_si128(t4, 0x04);
  543|  56.0k|    *t1 = _mm_xor_si128(*t1, t4);
  544|  56.0k|    t4 = _mm_slli_si128(t4, 0x04);
  545|  56.0k|    *t1 = _mm_xor_si128(*t1, t4);
  546|  56.0k|    *t1 = _mm_xor_si128(*t1, *t2);
  547|  56.0k|}
slow-hash.c:aes_256_assist2:
  550|  44.8k|{
  551|  44.8k|    __m128i t2, t4;
  552|  44.8k|    t4 = _mm_aeskeygenassist_si128(*t1, 0x00);
  553|  44.8k|    t2 = _mm_shuffle_epi32(t4, 0xaa);
  554|  44.8k|    t4 = _mm_slli_si128(*t3, 0x04);
  555|  44.8k|    *t3 = _mm_xor_si128(*t3, t4);
  556|  44.8k|    t4 = _mm_slli_si128(t4, 0x04);
  557|  44.8k|    *t3 = _mm_xor_si128(*t3, t4);
  558|  44.8k|    t4 = _mm_slli_si128(t4, 0x04);
  559|  44.8k|    *t3 = _mm_xor_si128(*t3, t4);
  560|  44.8k|    *t3 = _mm_xor_si128(*t3, t2);
  561|  44.8k|}
slow-hash.c:aes_pseudo_round:
  642|  91.7M|{
  643|  91.7M|    __m128i *k = R128(expandedKey);
  ------------------
  |  |  416|  91.7M|#define R128(x) ((__m128i *) (x))
  ------------------
  644|  91.7M|    __m128i d;
  645|  91.7M|    int i;
  646|       |
  647|   826M|    for(i = 0; i < nblocks; i++)
  ------------------
  |  Branch (647:16): [True: 734M, False: 91.7M]
  ------------------
  648|   734M|    {
  649|   734M|        d = _mm_loadu_si128(R128(in + i * AES_BLOCK_SIZE));
  ------------------
  |  |  416|   734M|#define R128(x) ((__m128i *) (x))
  ------------------
  650|   734M|        d = _mm_aesenc_si128(d, *R128(&k[0]));
  ------------------
  |  |  416|   734M|#define R128(x) ((__m128i *) (x))
  ------------------
  651|   734M|        d = _mm_aesenc_si128(d, *R128(&k[1]));
  ------------------
  |  |  416|   734M|#define R128(x) ((__m128i *) (x))
  ------------------
  652|   734M|        d = _mm_aesenc_si128(d, *R128(&k[2]));
  ------------------
  |  |  416|   734M|#define R128(x) ((__m128i *) (x))
  ------------------
  653|   734M|        d = _mm_aesenc_si128(d, *R128(&k[3]));
  ------------------
  |  |  416|   734M|#define R128(x) ((__m128i *) (x))
  ------------------
  654|   734M|        d = _mm_aesenc_si128(d, *R128(&k[4]));
  ------------------
  |  |  416|   734M|#define R128(x) ((__m128i *) (x))
  ------------------
  655|   734M|        d = _mm_aesenc_si128(d, *R128(&k[5]));
  ------------------
  |  |  416|   734M|#define R128(x) ((__m128i *) (x))
  ------------------
  656|   734M|        d = _mm_aesenc_si128(d, *R128(&k[6]));
  ------------------
  |  |  416|   734M|#define R128(x) ((__m128i *) (x))
  ------------------
  657|   734M|        d = _mm_aesenc_si128(d, *R128(&k[7]));
  ------------------
  |  |  416|   734M|#define R128(x) ((__m128i *) (x))
  ------------------
  658|   734M|        d = _mm_aesenc_si128(d, *R128(&k[8]));
  ------------------
  |  |  416|   734M|#define R128(x) ((__m128i *) (x))
  ------------------
  659|   734M|        d = _mm_aesenc_si128(d, *R128(&k[9]));
  ------------------
  |  |  416|   734M|#define R128(x) ((__m128i *) (x))
  ------------------
  660|   734M|        _mm_storeu_si128((R128(out + i * AES_BLOCK_SIZE)), d);
  ------------------
  |  |  416|   734M|#define R128(x) ((__m128i *) (x))
  ------------------
  661|   734M|    }
  662|  91.7M|}
slow-hash.c:aes_pseudo_round_xor:
  680|  91.7M|{
  681|  91.7M|    __m128i *k = R128(expandedKey);
  ------------------
  |  |  416|  91.7M|#define R128(x) ((__m128i *) (x))
  ------------------
  682|  91.7M|    __m128i *x = R128(xor);
  ------------------
  |  |  416|  91.7M|#define R128(x) ((__m128i *) (x))
  ------------------
  683|  91.7M|    __m128i d;
  684|  91.7M|    int i;
  685|       |
  686|   826M|    for(i = 0; i < nblocks; i++)
  ------------------
  |  Branch (686:16): [True: 734M, False: 91.7M]
  ------------------
  687|   734M|    {
  688|   734M|        d = _mm_loadu_si128(R128(in + i * AES_BLOCK_SIZE));
  ------------------
  |  |  416|   734M|#define R128(x) ((__m128i *) (x))
  ------------------
  689|   734M|        d = _mm_xor_si128(d, *R128(x++));
  ------------------
  |  |  416|   734M|#define R128(x) ((__m128i *) (x))
  ------------------
  690|   734M|        d = _mm_aesenc_si128(d, *R128(&k[0]));
  ------------------
  |  |  416|   734M|#define R128(x) ((__m128i *) (x))
  ------------------
  691|   734M|        d = _mm_aesenc_si128(d, *R128(&k[1]));
  ------------------
  |  |  416|   734M|#define R128(x) ((__m128i *) (x))
  ------------------
  692|   734M|        d = _mm_aesenc_si128(d, *R128(&k[2]));
  ------------------
  |  |  416|   734M|#define R128(x) ((__m128i *) (x))
  ------------------
  693|   734M|        d = _mm_aesenc_si128(d, *R128(&k[3]));
  ------------------
  |  |  416|   734M|#define R128(x) ((__m128i *) (x))
  ------------------
  694|   734M|        d = _mm_aesenc_si128(d, *R128(&k[4]));
  ------------------
  |  |  416|   734M|#define R128(x) ((__m128i *) (x))
  ------------------
  695|   734M|        d = _mm_aesenc_si128(d, *R128(&k[5]));
  ------------------
  |  |  416|   734M|#define R128(x) ((__m128i *) (x))
  ------------------
  696|   734M|        d = _mm_aesenc_si128(d, *R128(&k[6]));
  ------------------
  |  |  416|   734M|#define R128(x) ((__m128i *) (x))
  ------------------
  697|   734M|        d = _mm_aesenc_si128(d, *R128(&k[7]));
  ------------------
  |  |  416|   734M|#define R128(x) ((__m128i *) (x))
  ------------------
  698|   734M|        d = _mm_aesenc_si128(d, *R128(&k[8]));
  ------------------
  |  |  416|   734M|#define R128(x) ((__m128i *) (x))
  ------------------
  699|   734M|        d = _mm_aesenc_si128(d, *R128(&k[9]));
  ------------------
  |  |  416|   734M|#define R128(x) ((__m128i *) (x))
  ------------------
  700|   734M|        _mm_storeu_si128((R128(out + i * AES_BLOCK_SIZE)), d);
  ------------------
  |  |  416|   734M|#define R128(x) ((__m128i *) (x))
  ------------------
  701|   734M|    }
  702|  91.7M|}

tree_hash:
   62|      2|void tree_hash(const char (*hashes)[HASH_SIZE], size_t count, char *root_hash) {
   63|       |// The blockchain block at height 202612 https://moneroblocks.info/block/202612
   64|       |// contained 514 transactions, that triggered bad calculation of variable "cnt" in the original version of this function
   65|       |// as from CryptoNote code.
   66|       |//
   67|       |// This bug applies to all CN altcoins.
   68|       |//
   69|       |// Mathematical bug here was first published on 14:45:34 (GMT+2) 2014-09-04 by Rafal Freeman <rfree>
   70|       |// https://github.com/rfree2monero/bitmonero/commit/b417abfb7a297d09f1bbb6de29030f8de9952ac8
   71|       |// and soon also applied to CryptoNote (15:10 GMT+2), and BoolBerry used not fully correct work around:
   72|       |// the work around of sizeof(size_t)*8 or <<3 as used before in 2 coins and in BBL later was blocking
   73|       |// exploitation on normal platforms, how ever we strongly recommend the following fix because it removes
   74|       |// mistake in mathematical formula.
   75|       |
   76|      2|  assert(count > 0);
   77|      2|  if (count == 1) {
  ------------------
  |  Branch (77:7): [True: 2, False: 0]
  ------------------
   78|      2|    memcpy(root_hash, hashes, HASH_SIZE);
   79|      2|  } else if (count == 2) {
  ------------------
  |  Branch (79:14): [True: 0, False: 0]
  ------------------
   80|      0|    cn_fast_hash(hashes, 2 * HASH_SIZE, root_hash);
   81|      0|  } else {
   82|      0|    size_t i, j;
   83|       |
   84|      0|    size_t cnt = tree_hash_cnt( count );
   85|       |
   86|      0|    char *ints = calloc(cnt, HASH_SIZE);  // zero out as extra protection for using uninitialized mem
   87|      0|    assert(ints);
   88|       |
   89|      0|    memcpy(ints, hashes, (2 * cnt - count) * HASH_SIZE);
   90|       |
   91|      0|    for (i = 2 * cnt - count, j = 2 * cnt - count; j < cnt; i += 2, ++j) {
  ------------------
  |  Branch (91:52): [True: 0, False: 0]
  ------------------
   92|      0|      cn_fast_hash(hashes[i], 64, ints + j * HASH_SIZE);
   93|      0|    }
   94|      0|    assert(i == count);
   95|       |
   96|      0|    while (cnt > 2) {
  ------------------
  |  Branch (96:12): [True: 0, False: 0]
  ------------------
   97|      0|      cnt >>= 1;
   98|      0|      for (i = 0, j = 0; j < cnt; i += 2, ++j) {
  ------------------
  |  Branch (98:26): [True: 0, False: 0]
  ------------------
   99|      0|        cn_fast_hash(ints + i * HASH_SIZE, 64, ints + j * HASH_SIZE);
  100|      0|      }
  101|      0|    }
  102|       |
  103|      0|    cn_fast_hash(ints, 64, root_hash);
  104|      0|    free(ints);
  105|      0|  }
  106|      2|}

_ZN6crypto6wallet28derive_subaddress_public_keyERKNS_10public_keyERKNS_14key_derivationEmRS1_:
   47|  9.97k|      {
   48|  9.97k|        ec_scalar scalar;
   49|  9.97k|        derivation_to_scalar(d, index, scalar);
   50|  9.97k|        return monero_crypto_generate_subaddress_public_key(out.data, output_pub.data, scalar.data) == 0;
  ------------------
  |  |   36|  9.97k|#define monero_crypto_generate_subaddress_public_key monero_crypto_amd64_64_24k_generate_subaddress_public_key
  ------------------
   51|  9.97k|      }
_ZN6crypto6wallet23generate_key_derivationERKNS_10public_keyERKN4epee7mlockedIN5tools8scrubbedINS_9ec_scalarEEEEERNS_14key_derivationE:
   41|   125k|      {
   42|   125k|        return monero_crypto_generate_key_derivation(out.data, tx_pub.data, view_sec.data) == 0;
  ------------------
  |  |   35|   125k|#define monero_crypto_generate_key_derivation monero_crypto_amd64_64_24k_generate_key_derivation
  ------------------
   43|   125k|      }

_ZNK10cryptonote12account_keys10get_deviceEv:
   56|   130k|  hw::device& account_keys::get_device() const  {
   57|   130k|    return *m_device;
   58|   130k|  }
_ZN10cryptonote12account_keys19xor_with_key_streamERKN4epee7mlockedIN5tools8scrubbedINSt3__15arrayIhLm32EEEEEEE:
   88|      1|  {
   89|       |    // encrypt a large enough byte stream with chacha20
   90|      1|    epee::wipeable_string key_stream = get_key_stream(key, m_encryption_iv, sizeof(crypto::secret_key) * (2 + m_multisig_keys.size()));
   91|      1|    const char *ptr = key_stream.data();
   92|     33|    for (size_t i = 0; i < sizeof(crypto::secret_key); ++i)
  ------------------
  |  Branch (92:24): [True: 32, False: 1]
  ------------------
   93|     32|      m_spend_secret_key.data[i] ^= *ptr++;
   94|     33|    for (size_t i = 0; i < sizeof(crypto::secret_key); ++i)
  ------------------
  |  Branch (94:24): [True: 32, False: 1]
  ------------------
   95|     32|      m_view_secret_key.data[i] ^= *ptr++;
   96|      1|    for (crypto::secret_key &k: m_multisig_keys)
  ------------------
  |  Branch (96:31): [True: 0, False: 1]
  ------------------
   97|      0|    {
   98|      0|      for (size_t i = 0; i < sizeof(crypto::secret_key); ++i)
  ------------------
  |  Branch (98:26): [True: 0, False: 0]
  ------------------
   99|      0|        k.data[i] ^= *ptr++;
  100|      0|    }
  101|      1|  }
_ZN10cryptonote12account_keys7encryptERKN4epee7mlockedIN5tools8scrubbedINSt3__15arrayIhLm32EEEEEEE:
  104|      1|  {
  105|      1|    m_encryption_iv = crypto::rand<crypto::chacha_iv>();
  106|      1|    xor_with_key_stream(key);
  107|      1|  }
_ZN10cryptonote12account_keys15encrypt_viewkeyERKN4epee7mlockedIN5tools8scrubbedINSt3__15arrayIhLm32EEEEEEE:
  115|      1|  {
  116|       |    // encrypt a large enough byte stream with chacha20
  117|      1|    epee::wipeable_string key_stream = get_key_stream(key, m_encryption_iv, sizeof(crypto::secret_key) * 2);
  118|      1|    const char *ptr = key_stream.data();
  119|      1|    ptr += sizeof(crypto::secret_key);
  120|     33|    for (size_t i = 0; i < sizeof(crypto::secret_key); ++i)
  ------------------
  |  Branch (120:24): [True: 32, False: 1]
  ------------------
  121|     32|      m_view_secret_key.data[i] ^= *ptr++;
  122|      1|  }
_ZN10cryptonote12account_keys15decrypt_viewkeyERKN4epee7mlockedIN5tools8scrubbedINSt3__15arrayIhLm32EEEEEEE:
  125|      1|  {
  126|      1|    encrypt_viewkey(key);
  127|      1|  }
_ZN10cryptonote12account_baseC2Ev:
  130|      1|  {
  131|      1|    set_null();
  132|      1|  }
_ZN10cryptonote12account_base8set_nullEv:
  135|      1|  {
  136|      1|    m_keys = account_keys();
  137|      1|    m_creation_timestamp = 0;
  138|      1|  }
_ZN10cryptonote12account_base6deinitEv:
  141|      1|  {
  142|      1|    try{
  143|      1|      m_keys.get_device().disconnect();
  144|      1|    } catch (const std::exception &e){
  145|      0|      MERROR("Device disconnect exception: " << e.what());
  ------------------
  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  ------------------
  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  146|      0|    }
  147|      1|  }
_ZN10cryptonote12account_base8generateERKN4epee7mlockedIN5tools8scrubbedIN6crypto9ec_scalarEEEEEbb:
  167|      1|  {
  168|      1|    crypto::secret_key first = generate_keys(m_keys.m_account_address.m_spend_public_key, m_keys.m_spend_secret_key, recovery_key, recover);
  169|       |
  170|       |    // rng for generating second set of keys is hash of first rng.  means only one set of electrum-style words needed for recovery
  171|      1|    crypto::secret_key second;
  172|      1|    keccak((uint8_t *)&m_keys.m_spend_secret_key, sizeof(crypto::secret_key), (uint8_t *)&second, sizeof(crypto::secret_key));
  173|       |
  174|      1|    generate_keys(m_keys.m_account_address.m_view_public_key, m_keys.m_view_secret_key, second, two_random ? false : true);
  ------------------
  |  Branch (174:97): [True: 0, False: 1]
  ------------------
  175|       |
  176|      1|    struct tm timestamp = {0};
  177|      1|    timestamp.tm_year = 2014 - 1900;  // year 2014
  178|      1|    timestamp.tm_mon = 6 - 1;  // month june
  179|      1|    timestamp.tm_mday = 8;  // 8th of june
  180|      1|    timestamp.tm_hour = 0;
  181|      1|    timestamp.tm_min = 0;
  182|      1|    timestamp.tm_sec = 0;
  183|       |
  184|      1|    if (recover)
  ------------------
  |  Branch (184:9): [True: 1, False: 0]
  ------------------
  185|      1|    {
  186|      1|      m_creation_timestamp = mktime(&timestamp);
  187|      1|      if (m_creation_timestamp == (uint64_t)-1) // failure
  ------------------
  |  Branch (187:11): [True: 0, False: 1]
  ------------------
  188|      0|        m_creation_timestamp = 0; // lowest value
  189|      1|    }
  190|      0|    else
  191|      0|    {
  192|      0|      m_creation_timestamp = time(NULL);
  193|      0|    }
  194|      1|    return first;
  195|      1|  }
_ZNK10cryptonote12account_base8get_keysEv:
  268|  14.4k|  {
  269|  14.4k|    return m_keys;
  270|  14.4k|  }
account.cpp:_ZN10cryptonoteL14get_key_streamERKN4epee7mlockedIN5tools8scrubbedINSt3__15arrayIhLm32EEEEEEERKN6crypto9chacha_ivEm:
   75|      2|  {
   76|       |    // derive a new key
   77|      2|    crypto::chacha_key key;
   78|      2|    derive_key(base_key, key);
   79|       |
   80|       |    // chacha
   81|      2|    epee::wipeable_string buffer0(std::string(bytes, '\0'));
   82|      2|    epee::wipeable_string buffer1 = buffer0;
   83|      2|    crypto::chacha20(buffer0.data(), buffer0.size(), key, iv, buffer1.data());
   84|      2|    return buffer1;
   85|      2|  }
account.cpp:_ZN10cryptonoteL10derive_keyERKN4epee7mlockedIN5tools8scrubbedINSt3__15arrayIhLm32EEEEEEERS8_:
   66|      2|  {
   67|      2|    static_assert(sizeof(base_key) == sizeof(crypto::hash), "chacha key and hash should be the same size");
   68|      2|    epee::mlocked<tools::scrubbed_arr<char, sizeof(base_key)+1>> data;
   69|      2|    memcpy(data.data(), &base_key, sizeof(base_key));
   70|      2|    data[sizeof(base_key)] = config::HASH_KEY_MEMORY;
   71|      2|    crypto::generate_chacha_key(data.data(), sizeof(data), key, 1);
   72|      2|  }

_ZNK10cryptonote12account_base10get_deviceEv:
   87|  31.2k|    hw::device& get_device() const  {return m_keys.get_device();}
_ZN10cryptonote12account_base12encrypt_keysERKN4epee7mlockedIN5tools8scrubbedINSt3__15arrayIhLm32EEEEEEE:
  101|      1|    void encrypt_keys(const crypto::chacha_key &key) { m_keys.encrypt(key); }
_ZN10cryptonote12account_base15decrypt_viewkeyERKN4epee7mlockedIN5tools8scrubbedINSt3__15arrayIhLm32EEEEEEE:
  104|      1|    void decrypt_viewkey(const crypto::chacha_key &key) { m_keys.decrypt_viewkey(key); }

_ZN10cryptonote11transactionD2Ev:
  413|  2.71k|  {
  414|  2.71k|  }
_ZN10cryptonote22account_public_address19do_serialize_objectILb0E14binary_archiveEEbRT0_IXT_EE:
  516|   114k|    BEGIN_SERIALIZE_OBJECT()
  ------------------
  |  |  184|   114k|  bool do_serialize_object(Archive<W> &ar){
  ------------------
  517|   114k|      FIELD(m_spend_public_key)
  ------------------
  |  |  226|   114k|  do {							\
  |  |  227|   114k|    ar.tag(#f);						\
  |  |  228|   114k|    bool r = do_serialize(ar, f);			\
  |  |  229|   114k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 114k]
  |  |  |  Branch (229:15): [True: 1.21k, False: 112k]
  |  |  ------------------
  |  |  230|   114k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  518|   112k|      FIELD(m_view_public_key)
  ------------------
  |  |  226|   112k|  do {							\
  |  |  227|   112k|    ar.tag(#f);						\
  |  |  228|   112k|    bool r = do_serialize(ar, f);			\
  |  |  229|   112k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 112k]
  |  |  |  Branch (229:15): [True: 57, False: 112k]
  |  |  ------------------
  |  |  230|   112k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  519|   112k|    END_SERIALIZE()
  ------------------
  |  |  207|   112k|  return ar.good();				\
  |  |  208|   112k|  }
  ------------------
_ZN10cryptonote18transaction_prefixC2Ev:
  193|  33.1k|    transaction_prefix(){ set_null(); }
_ZN10cryptonote18transaction_prefix8set_nullEv:
  195|  35.9k|    {
  196|  35.9k|      version = 1;
  197|  35.9k|      unlock_time = 0;
  198|  35.9k|      vin.clear();
  199|  35.9k|      vout.clear();
  200|  35.9k|      extra.clear();
  201|  35.9k|    }
_ZN10cryptonote18transaction_prefix19member_do_serializeILb0E14binary_archiveEEbRT0_IXT_EE:
  183|  12.4k|    BEGIN_SERIALIZE()
  ------------------
  |  |  157|  12.4k|  bool member_do_serialize(Archive<W> &ar) {
  ------------------
  184|  12.4k|      VARINT_FIELD(version)
  ------------------
  |  |  252|  12.4k|  do {						\
  |  |  253|  12.4k|    ar.tag(#f);					\
  |  |  254|  12.4k|    ar.serialize_varint(f);			\
  |  |  255|  12.4k|    if (!ar.good()) return false;		\
  |  |  ------------------
  |  |  |  Branch (255:9): [True: 15, False: 12.4k]
  |  |  ------------------
  |  |  256|  12.4k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (256:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  185|  12.4k|      if((version == 0 || CURRENT_TRANSACTION_VERSION < version)) return false;
  ------------------
  |  |   45|  12.3k|#define CURRENT_TRANSACTION_VERSION                     2
  ------------------
  |  Branch (185:11): [True: 38, False: 12.3k]
  |  Branch (185:27): [True: 153, False: 12.2k]
  ------------------
  186|  12.2k|      VARINT_FIELD(unlock_time)
  ------------------
  |  |  252|  12.2k|  do {						\
  |  |  253|  12.2k|    ar.tag(#f);					\
  |  |  254|  12.2k|    ar.serialize_varint(f);			\
  |  |  255|  12.2k|    if (!ar.good()) return false;		\
  |  |  ------------------
  |  |  |  Branch (255:9): [True: 14, False: 12.1k]
  |  |  ------------------
  |  |  256|  12.2k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (256:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  187|  12.1k|      FIELD(vin)
  ------------------
  |  |  226|  12.1k|  do {							\
  |  |  227|  12.1k|    ar.tag(#f);						\
  |  |  228|  12.1k|    bool r = do_serialize(ar, f);			\
  |  |  229|  12.1k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 662, False: 11.5k]
  |  |  |  Branch (229:15): [True: 0, False: 11.5k]
  |  |  ------------------
  |  |  230|  12.1k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  188|  11.5k|      FIELD(vout)
  ------------------
  |  |  226|  11.5k|  do {							\
  |  |  227|  11.5k|    ar.tag(#f);						\
  |  |  228|  11.5k|    bool r = do_serialize(ar, f);			\
  |  |  229|  11.5k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 512, False: 11.0k]
  |  |  |  Branch (229:15): [True: 0, False: 11.0k]
  |  |  ------------------
  |  |  230|  11.5k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  189|  11.0k|      FIELD(extra)
  ------------------
  |  |  226|  11.0k|  do {							\
  |  |  227|  11.0k|    ar.tag(#f);						\
  |  |  228|  11.0k|    bool r = do_serialize(ar, f);			\
  |  |  229|  11.0k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 136, False: 10.8k]
  |  |  |  Branch (229:15): [True: 0, False: 10.8k]
  |  |  ------------------
  |  |  230|  11.0k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  190|  10.8k|    END_SERIALIZE()
  ------------------
  |  |  207|  10.8k|  return ar.good();				\
  |  |  208|  11.0k|  }
  ------------------
_ZN10cryptonote8txin_gen19do_serialize_objectILb0E14binary_archiveEEbRT0_IXT_EE:
  105|    928|    BEGIN_SERIALIZE_OBJECT()
  ------------------
  |  |  184|    928|  bool do_serialize_object(Archive<W> &ar){
  ------------------
  106|    928|      VARINT_FIELD(height)
  ------------------
  |  |  252|    928|  do {						\
  |  |  253|    928|    ar.tag(#f);					\
  |  |  254|    928|    ar.serialize_varint(f);			\
  |  |  255|    928|    if (!ar.good()) return false;		\
  |  |  ------------------
  |  |  |  Branch (255:9): [True: 14, False: 914]
  |  |  ------------------
  |  |  256|    928|  } while(0);
  |  |  ------------------
  |  |  |  Branch (256:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  107|    914|    END_SERIALIZE()
  ------------------
  |  |  207|    914|  return ar.good();				\
  |  |  208|    928|  }
  ------------------
_ZN10cryptonote14txin_to_script19do_serialize_objectILb0E14binary_archiveEEbRT0_IXT_EE:
  116|  2.77k|    BEGIN_SERIALIZE_OBJECT()
  ------------------
  |  |  184|  2.77k|  bool do_serialize_object(Archive<W> &ar){
  ------------------
  117|  2.77k|      FIELD(prev)
  ------------------
  |  |  226|  2.77k|  do {							\
  |  |  227|  2.77k|    ar.tag(#f);						\
  |  |  228|  2.77k|    bool r = do_serialize(ar, f);			\
  |  |  229|  2.77k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 2.77k]
  |  |  |  Branch (229:15): [True: 138, False: 2.63k]
  |  |  ------------------
  |  |  230|  2.77k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  118|  2.63k|      VARINT_FIELD(prevout)
  ------------------
  |  |  252|  2.63k|  do {						\
  |  |  253|  2.63k|    ar.tag(#f);					\
  |  |  254|  2.63k|    ar.serialize_varint(f);			\
  |  |  255|  2.63k|    if (!ar.good()) return false;		\
  |  |  ------------------
  |  |  |  Branch (255:9): [True: 13, False: 2.62k]
  |  |  ------------------
  |  |  256|  2.63k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (256:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  119|  2.62k|      FIELD(sigset)
  ------------------
  |  |  226|  2.62k|  do {							\
  |  |  227|  2.62k|    ar.tag(#f);						\
  |  |  228|  2.62k|    bool r = do_serialize(ar, f);			\
  |  |  229|  2.62k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 6, False: 2.61k]
  |  |  |  Branch (229:15): [True: 0, False: 2.61k]
  |  |  ------------------
  |  |  230|  2.62k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  120|  2.61k|    END_SERIALIZE()
  ------------------
  |  |  207|  2.61k|  return ar.good();				\
  |  |  208|  2.62k|  }
  ------------------
_ZN10cryptonote18txin_to_scripthash19do_serialize_objectILb0E14binary_archiveEEbRT0_IXT_EE:
  130|  3.97k|    BEGIN_SERIALIZE_OBJECT()
  ------------------
  |  |  184|  3.97k|  bool do_serialize_object(Archive<W> &ar){
  ------------------
  131|  3.97k|      FIELD(prev)
  ------------------
  |  |  226|  3.97k|  do {							\
  |  |  227|  3.97k|    ar.tag(#f);						\
  |  |  228|  3.97k|    bool r = do_serialize(ar, f);			\
  |  |  229|  3.97k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 3.97k]
  |  |  |  Branch (229:15): [True: 32, False: 3.94k]
  |  |  ------------------
  |  |  230|  3.97k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  132|  3.94k|      VARINT_FIELD(prevout)
  ------------------
  |  |  252|  3.94k|  do {						\
  |  |  253|  3.94k|    ar.tag(#f);					\
  |  |  254|  3.94k|    ar.serialize_varint(f);			\
  |  |  255|  3.94k|    if (!ar.good()) return false;		\
  |  |  ------------------
  |  |  |  Branch (255:9): [True: 12, False: 3.93k]
  |  |  ------------------
  |  |  256|  3.94k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (256:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  133|  3.93k|      FIELD(script)
  ------------------
  |  |  226|  3.93k|  do {							\
  |  |  227|  3.93k|    ar.tag(#f);						\
  |  |  228|  3.93k|    bool r = do_serialize(ar, f);			\
  |  |  229|  3.93k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 26, False: 3.90k]
  |  |  |  Branch (229:15): [True: 0, False: 3.90k]
  |  |  ------------------
  |  |  230|  3.93k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  134|  3.90k|      FIELD(sigset)
  ------------------
  |  |  226|  3.90k|  do {							\
  |  |  227|  3.90k|    ar.tag(#f);						\
  |  |  228|  3.90k|    bool r = do_serialize(ar, f);			\
  |  |  229|  3.90k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 5, False: 3.90k]
  |  |  |  Branch (229:15): [True: 0, False: 3.90k]
  |  |  ------------------
  |  |  230|  3.90k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  135|  3.90k|    END_SERIALIZE()
  ------------------
  |  |  207|  3.90k|  return ar.good();				\
  |  |  208|  3.90k|  }
  ------------------
_ZN10cryptonote15txout_to_script19do_serialize_objectILb0E14binary_archiveEEbRT0_IXT_EE:
   66|  13.5k|    BEGIN_SERIALIZE_OBJECT()
  ------------------
  |  |  184|  13.5k|  bool do_serialize_object(Archive<W> &ar){
  ------------------
   67|  13.5k|      FIELD(keys)
  ------------------
  |  |  226|  13.5k|  do {							\
  |  |  227|  13.5k|    ar.tag(#f);						\
  |  |  228|  13.5k|    bool r = do_serialize(ar, f);			\
  |  |  229|  13.5k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 296, False: 13.2k]
  |  |  |  Branch (229:15): [True: 0, False: 13.2k]
  |  |  ------------------
  |  |  230|  13.5k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
   68|  13.2k|      FIELD(script)
  ------------------
  |  |  226|  13.2k|  do {							\
  |  |  227|  13.2k|    ar.tag(#f);						\
  |  |  228|  13.2k|    bool r = do_serialize(ar, f);			\
  |  |  229|  13.2k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 18, False: 13.2k]
  |  |  |  Branch (229:15): [True: 0, False: 13.2k]
  |  |  ------------------
  |  |  230|  13.2k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
   69|  13.2k|    END_SERIALIZE()
  ------------------
  |  |  207|  13.2k|  return ar.good();				\
  |  |  208|  13.2k|  }
  ------------------
_ZN10cryptonote11txin_to_key19do_serialize_objectILb0E14binary_archiveEEbRT0_IXT_EE:
  144|  2.52k|    BEGIN_SERIALIZE_OBJECT()
  ------------------
  |  |  184|  2.52k|  bool do_serialize_object(Archive<W> &ar){
  ------------------
  145|  2.52k|      VARINT_FIELD(amount)
  ------------------
  |  |  252|  2.52k|  do {						\
  |  |  253|  2.52k|    ar.tag(#f);					\
  |  |  254|  2.52k|    ar.serialize_varint(f);			\
  |  |  255|  2.52k|    if (!ar.good()) return false;		\
  |  |  ------------------
  |  |  |  Branch (255:9): [True: 9, False: 2.52k]
  |  |  ------------------
  |  |  256|  2.52k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (256:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  146|  2.52k|      FIELD(key_offsets)
  ------------------
  |  |  226|  2.52k|  do {							\
  |  |  227|  2.52k|    ar.tag(#f);						\
  |  |  228|  2.52k|    bool r = do_serialize(ar, f);			\
  |  |  229|  2.52k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 150, False: 2.37k]
  |  |  |  Branch (229:15): [True: 0, False: 2.37k]
  |  |  ------------------
  |  |  230|  2.52k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  147|  2.37k|      FIELD(k_image)
  ------------------
  |  |  226|  2.37k|  do {							\
  |  |  227|  2.37k|    ar.tag(#f);						\
  |  |  228|  2.37k|    bool r = do_serialize(ar, f);			\
  |  |  229|  2.37k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 2.37k]
  |  |  |  Branch (229:15): [True: 100, False: 2.27k]
  |  |  ------------------
  |  |  230|  2.37k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  148|  2.27k|    END_SERIALIZE()
  ------------------
  |  |  207|  2.27k|  return ar.good();				\
  |  |  208|  2.37k|  }
  ------------------
_ZN10cryptonote6tx_out19do_serialize_objectILb0E14binary_archiveEEbRT0_IXT_EE:
  162|  18.4k|    BEGIN_SERIALIZE_OBJECT()
  ------------------
  |  |  184|  18.4k|  bool do_serialize_object(Archive<W> &ar){
  ------------------
  163|  18.4k|      VARINT_FIELD(amount)
  ------------------
  |  |  252|  18.4k|  do {						\
  |  |  253|  18.4k|    ar.tag(#f);					\
  |  |  254|  18.4k|    ar.serialize_varint(f);			\
  |  |  255|  18.4k|    if (!ar.good()) return false;		\
  |  |  ------------------
  |  |  |  Branch (255:9): [True: 5, False: 18.4k]
  |  |  ------------------
  |  |  256|  18.4k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (256:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  164|  18.4k|      FIELD(target)
  ------------------
  |  |  226|  18.4k|  do {							\
  |  |  227|  18.4k|    ar.tag(#f);						\
  |  |  228|  18.4k|    bool r = do_serialize(ar, f);			\
  |  |  229|  18.4k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 340, False: 18.1k]
  |  |  |  Branch (229:15): [True: 43, False: 18.0k]
  |  |  ------------------
  |  |  230|  18.4k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  165|  18.0k|    END_SERIALIZE()
  ------------------
  |  |  207|  18.0k|  return ar.good();				\
  |  |  208|  18.4k|  }
  ------------------
_ZN10cryptonote12txout_to_keyC2Ev:
   80|  5.81k|    txout_to_key(): key() { }
_ZN10cryptonote19txout_to_tagged_keyC2Ev:
   88|    397|    txout_to_tagged_key(): key(), view_tag() { }
_ZN10cryptonote19txout_to_tagged_key19do_serialize_objectILb0E14binary_archiveEEbRT0_IXT_EE:
   93|    397|    BEGIN_SERIALIZE_OBJECT()
  ------------------
  |  |  184|    397|  bool do_serialize_object(Archive<W> &ar){
  ------------------
   94|    397|      FIELD(key)
  ------------------
  |  |  226|    397|  do {							\
  |  |  227|    397|    ar.tag(#f);						\
  |  |  228|    397|    bool r = do_serialize(ar, f);			\
  |  |  229|    397|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 397]
  |  |  |  Branch (229:15): [True: 9, False: 388]
  |  |  ------------------
  |  |  230|    397|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
   95|    388|      FIELD(view_tag)
  ------------------
  |  |  226|    388|  do {							\
  |  |  227|    388|    ar.tag(#f);						\
  |  |  228|    388|    bool r = do_serialize(ar, f);			\
  |  |  229|    388|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 388]
  |  |  |  Branch (229:15): [True: 1, False: 387]
  |  |  ------------------
  |  |  230|    388|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
   96|    387|    END_SERIALIZE()
  ------------------
  |  |  207|    387|  return ar.good();				\
  |  |  208|    388|  }
  ------------------
_ZNK10cryptonote11transaction13is_hash_validEv:
  232|  1.36k|    bool is_hash_valid() const { return hash_valid.load(std::memory_order_acquire); }
_ZNK10cryptonote11transaction14set_hash_validEb:
  233|  2.72k|    void set_hash_valid(bool v) const { hash_valid.store(v,std::memory_order_release); }
_ZNK10cryptonote11transaction22is_prunable_hash_validEv:
  234|  1.35k|    bool is_prunable_hash_valid() const { return prunable_hash_valid.load(std::memory_order_acquire); }
_ZNK10cryptonote11transaction23set_prunable_hash_validEb:
  235|  2.71k|    void set_prunable_hash_valid(bool v) const { prunable_hash_valid.store(v,std::memory_order_release); }
_ZNK10cryptonote11transaction18is_blob_size_validEv:
  236|  1.35k|    bool is_blob_size_valid() const { return blob_size_valid.load(std::memory_order_acquire); }
_ZNK10cryptonote11transaction19set_blob_size_validEb:
  237|  2.72k|    void set_blob_size_valid(bool v) const { blob_size_valid.store(v,std::memory_order_release); }
_ZNK10cryptonote11transaction8set_hashERKN6crypto4hashE:
  238|      1|    void set_hash(const crypto::hash &h) const { hash = h; set_hash_valid(true); }
_ZNK10cryptonote11transaction13set_blob_sizeEm:
  240|      2|    void set_blob_size(size_t sz) const { blob_size = sz; set_blob_size_valid(true); }
_ZZN10cryptonote11transaction18get_signature_sizeERKN5boost7variantINS_8txin_genEJNS_14txin_to_scriptENS_18txin_to_scripthashENS_11txin_to_keyEEEEENK27txin_signature_size_visitorclERKS3_:
  443|      3|      size_t operator()(const txin_gen& txin) const{return 0;}
_ZN10cryptonote5blockC2Ev:
  481|      2|    block(): block_header(), hash_valid(false) {}
_ZN10cryptonote5blockaSERKS0_:
  483|      1|    block &operator=(const block &b) { block_header::operator=(b); hash_valid = false; miner_tx = b.miner_tx; tx_hashes = b.tx_hashes; if (b.is_hash_valid()) { hash = b.hash; set_hash_valid(true); } return *this; }
  ------------------
  |  Branch (483:140): [True: 0, False: 1]
  ------------------
_ZN10cryptonote5block17invalidate_hashesEv:
  484|      2|    void invalidate_hashes() { set_hash_valid(false); }
_ZNK10cryptonote5block13is_hash_validEv:
  485|      2|    bool is_hash_valid() const { return hash_valid.load(std::memory_order_acquire); }
_ZNK10cryptonote5block14set_hash_validEb:
  486|      3|    void set_hash_valid(bool v) const { hash_valid.store(v,std::memory_order_release); }
_ZNK10cryptonote5block8set_hashERKN6crypto4hashE:
  487|      1|    void set_hash(const crypto::hash &h) const { hash = h; set_hash_valid(true); }
_ZNK10cryptonote22account_public_addresseqERKS0_:
  527|  25.4M|    {
  528|  25.4M|      return m_spend_public_key == rhs.m_spend_public_key &&
  ------------------
  |  Branch (528:14): [True: 7.00M, False: 18.4M]
  ------------------
  529|  25.4M|             m_view_public_key == rhs.m_view_public_key;
  ------------------
  |  Branch (529:14): [True: 59.7k, False: 6.95M]
  ------------------
  530|  25.4M|    }
_ZN10cryptonote7keypair8generateERN2hw6deviceE:
  544|  98.2k|    {
  545|  98.2k|      keypair k;
  546|  98.2k|      hwdev.generate_keys(k.pub, k.sec);
  547|  98.2k|      return k;
  548|  98.2k|    }
_ZN10cryptonote11transactionaSERKS0_:
  376|      1|  {
  377|      1|    transaction_prefix::operator=(t);
  378|       |
  379|      1|    set_hash_valid(false);
  380|      1|    set_prunable_hash_valid(false);
  381|      1|    set_blob_size_valid(false);
  382|      1|    signatures = t.signatures;
  383|      1|    rct_signatures = t.rct_signatures;
  384|      1|    if (t.is_hash_valid())
  ------------------
  |  Branch (384:9): [True: 0, False: 1]
  ------------------
  385|      0|    {
  386|      0|      hash = t.hash;
  387|      0|      set_hash_valid(true);
  388|      0|    }
  389|      1|    if (t.is_prunable_hash_valid())
  ------------------
  |  Branch (389:9): [True: 0, False: 1]
  ------------------
  390|      0|    {
  391|      0|      prunable_hash = t.prunable_hash;
  392|      0|      set_prunable_hash_valid(true);
  393|      0|    }
  394|      1|    if (t.is_blob_size_valid())
  ------------------
  |  Branch (394:9): [True: 0, False: 1]
  ------------------
  395|      0|    {
  396|      0|      blob_size = t.blob_size;
  397|      0|      set_blob_size_valid(true);
  398|      0|    }
  399|      1|    pruned = t.pruned;
  400|      1|    unprunable_size = t.unprunable_size.load();
  401|      1|    prefix_size = t.prefix_size.load();
  402|      1|    return *this;
  403|      1|  }
_ZN10cryptonote11transaction8set_nullEv:
  418|  2.71k|  {
  419|  2.71k|    transaction_prefix::set_null();
  420|  2.71k|    signatures.clear();
  421|  2.71k|    rct_signatures.type = rct::RCTTypeNull;
  422|  2.71k|    set_hash_valid(false);
  423|  2.71k|    set_prunable_hash_valid(false);
  424|  2.71k|    set_blob_size_valid(false);
  425|  2.71k|    pruned = false;
  426|  2.71k|    unprunable_size = 0;
  427|  2.71k|    prefix_size = 0;
  428|  2.71k|  }
_ZN10cryptonote11transaction17invalidate_hashesEv:
  432|      1|  {
  433|      1|    set_hash_valid(false);
  434|      1|    set_prunable_hash_valid(false);
  435|      1|    set_blob_size_valid(false);
  436|      1|  }
_ZN10cryptonote11transaction18get_signature_sizeERKN5boost7variantINS_8txin_genEJNS_14txin_to_scriptENS_18txin_to_scripthashENS_11txin_to_keyEEEE:
  440|      3|  {
  441|      3|    struct txin_signature_size_visitor : public boost::static_visitor<size_t>
  442|      3|    {
  443|      3|      size_t operator()(const txin_gen& txin) const{return 0;}
  444|      3|      size_t operator()(const txin_to_script& txin) const{return 0;}
  445|      3|      size_t operator()(const txin_to_scripthash& txin) const{return 0;}
  446|      3|      size_t operator()(const txin_to_key& txin) const {return txin.key_offsets.size();}
  447|      3|    };
  448|       |
  449|      3|    return boost::apply_visitor(txin_signature_size_visitor(), tx_in);
  450|      3|  }
_ZNKSt3__14hashIN10cryptonote22account_public_addressEEclERKS2_:
  559|   137k|    {
  560|       |      // https://stackoverflow.com/a/17017281
  561|   137k|      size_t res = 17;
  562|   137k|      res = res * 31 + hash<crypto::public_key>()(addr.m_spend_public_key);
  563|   137k|      res = res * 31 + hash<crypto::public_key>()(addr.m_view_public_key);
  564|   137k|      return res;
  565|   137k|    }
_ZN10cryptonote11transactionC2Ev:
  407|  1.35k|  {
  408|  1.35k|    set_null();
  409|  1.35k|  }
_ZN10cryptonote11transactionC2ERKS0_:
  348|  1.35k|    transaction_prefix(t),
  349|  1.35k|    hash_valid(false),
  350|  1.35k|    prunable_hash_valid(false),
  351|  1.35k|    blob_size_valid(false),
  352|  1.35k|    signatures(t.signatures),
  353|  1.35k|    rct_signatures(t.rct_signatures),
  354|  1.35k|    pruned(t.pruned),
  355|  1.35k|    unprunable_size(t.unprunable_size.load()),
  356|  1.35k|    prefix_size(t.prefix_size.load())
  357|  1.35k|  {
  358|  1.35k|    if (t.is_hash_valid())
  ------------------
  |  Branch (358:9): [True: 0, False: 1.35k]
  ------------------
  359|      0|    {
  360|      0|      hash = t.hash;
  361|      0|      set_hash_valid(true);
  362|      0|    }
  363|  1.35k|    if (t.is_blob_size_valid())
  ------------------
  |  Branch (363:9): [True: 0, False: 1.35k]
  ------------------
  364|      0|    {
  365|      0|      blob_size = t.blob_size;
  366|      0|      set_blob_size_valid(true);
  367|      0|    }
  368|  1.35k|    if (t.is_prunable_hash_valid())
  ------------------
  |  Branch (368:9): [True: 0, False: 1.35k]
  ------------------
  369|      0|    {
  370|      0|      prunable_hash = t.prunable_hash;
  371|      0|      set_prunable_hash_valid(true);
  372|      0|    }
  373|  1.35k|  }
_ZN10cryptonote18transaction_prefix19member_do_serializeILb1E14binary_archiveEEbRT0_IXT_EE:
  183|     24|    BEGIN_SERIALIZE()
  ------------------
  |  |  157|     24|  bool member_do_serialize(Archive<W> &ar) {
  ------------------
  184|     24|      VARINT_FIELD(version)
  ------------------
  |  |  252|     24|  do {						\
  |  |  253|     24|    ar.tag(#f);					\
  |  |  254|     24|    ar.serialize_varint(f);			\
  |  |  255|     24|    if (!ar.good()) return false;		\
  |  |  ------------------
  |  |  |  Branch (255:9): [True: 0, False: 24]
  |  |  ------------------
  |  |  256|     24|  } while(0);
  |  |  ------------------
  |  |  |  Branch (256:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  185|     24|      if((version == 0 || CURRENT_TRANSACTION_VERSION < version)) return false;
  ------------------
  |  |   45|     24|#define CURRENT_TRANSACTION_VERSION                     2
  ------------------
  |  Branch (185:11): [True: 0, False: 24]
  |  Branch (185:27): [True: 0, False: 24]
  ------------------
  186|     24|      VARINT_FIELD(unlock_time)
  ------------------
  |  |  252|     24|  do {						\
  |  |  253|     24|    ar.tag(#f);					\
  |  |  254|     24|    ar.serialize_varint(f);			\
  |  |  255|     24|    if (!ar.good()) return false;		\
  |  |  ------------------
  |  |  |  Branch (255:9): [True: 0, False: 24]
  |  |  ------------------
  |  |  256|     24|  } while(0);
  |  |  ------------------
  |  |  |  Branch (256:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  187|     24|      FIELD(vin)
  ------------------
  |  |  226|     24|  do {							\
  |  |  227|     24|    ar.tag(#f);						\
  |  |  228|     24|    bool r = do_serialize(ar, f);			\
  |  |  229|     24|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 24]
  |  |  |  Branch (229:15): [True: 0, False: 24]
  |  |  ------------------
  |  |  230|     24|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  188|     24|      FIELD(vout)
  ------------------
  |  |  226|     24|  do {							\
  |  |  227|     24|    ar.tag(#f);						\
  |  |  228|     24|    bool r = do_serialize(ar, f);			\
  |  |  229|     24|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 24]
  |  |  |  Branch (229:15): [True: 0, False: 24]
  |  |  ------------------
  |  |  230|     24|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  189|     24|      FIELD(extra)
  ------------------
  |  |  226|     24|  do {							\
  |  |  227|     24|    ar.tag(#f);						\
  |  |  228|     24|    bool r = do_serialize(ar, f);			\
  |  |  229|     24|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 24]
  |  |  |  Branch (229:15): [True: 0, False: 24]
  |  |  ------------------
  |  |  230|     24|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  190|     24|    END_SERIALIZE()
  ------------------
  |  |  207|     24|  return ar.good();				\
  |  |  208|     24|  }
  ------------------
_ZN10cryptonote8txin_gen19do_serialize_objectILb1E14binary_archiveEEbRT0_IXT_EE:
  105|     18|    BEGIN_SERIALIZE_OBJECT()
  ------------------
  |  |  184|     18|  bool do_serialize_object(Archive<W> &ar){
  ------------------
  106|     18|      VARINT_FIELD(height)
  ------------------
  |  |  252|     18|  do {						\
  |  |  253|     18|    ar.tag(#f);					\
  |  |  254|     18|    ar.serialize_varint(f);			\
  |  |  255|     18|    if (!ar.good()) return false;		\
  |  |  ------------------
  |  |  |  Branch (255:9): [True: 0, False: 18]
  |  |  ------------------
  |  |  256|     18|  } while(0);
  |  |  ------------------
  |  |  |  Branch (256:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  107|     18|    END_SERIALIZE()
  ------------------
  |  |  207|     18|  return ar.good();				\
  |  |  208|     18|  }
  ------------------
_ZN10cryptonote14txin_to_script19do_serialize_objectILb1E14binary_archiveEEbRT0_IXT_EE:
  116|     50|    BEGIN_SERIALIZE_OBJECT()
  ------------------
  |  |  184|     50|  bool do_serialize_object(Archive<W> &ar){
  ------------------
  117|     50|      FIELD(prev)
  ------------------
  |  |  226|     50|  do {							\
  |  |  227|     50|    ar.tag(#f);						\
  |  |  228|     50|    bool r = do_serialize(ar, f);			\
  |  |  229|     50|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 50]
  |  |  |  Branch (229:15): [True: 0, False: 50]
  |  |  ------------------
  |  |  230|     50|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  118|     50|      VARINT_FIELD(prevout)
  ------------------
  |  |  252|     50|  do {						\
  |  |  253|     50|    ar.tag(#f);					\
  |  |  254|     50|    ar.serialize_varint(f);			\
  |  |  255|     50|    if (!ar.good()) return false;		\
  |  |  ------------------
  |  |  |  Branch (255:9): [True: 0, False: 50]
  |  |  ------------------
  |  |  256|     50|  } while(0);
  |  |  ------------------
  |  |  |  Branch (256:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  119|     50|      FIELD(sigset)
  ------------------
  |  |  226|     50|  do {							\
  |  |  227|     50|    ar.tag(#f);						\
  |  |  228|     50|    bool r = do_serialize(ar, f);			\
  |  |  229|     50|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 50]
  |  |  |  Branch (229:15): [True: 0, False: 50]
  |  |  ------------------
  |  |  230|     50|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  120|     50|    END_SERIALIZE()
  ------------------
  |  |  207|     50|  return ar.good();				\
  |  |  208|     50|  }
  ------------------
_ZN10cryptonote15txout_to_script19do_serialize_objectILb1E14binary_archiveEEbRT0_IXT_EE:
   66|     43|    BEGIN_SERIALIZE_OBJECT()
  ------------------
  |  |  184|     43|  bool do_serialize_object(Archive<W> &ar){
  ------------------
   67|     43|      FIELD(keys)
  ------------------
  |  |  226|     43|  do {							\
  |  |  227|     43|    ar.tag(#f);						\
  |  |  228|     43|    bool r = do_serialize(ar, f);			\
  |  |  229|     43|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 43]
  |  |  |  Branch (229:15): [True: 0, False: 43]
  |  |  ------------------
  |  |  230|     43|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
   68|     43|      FIELD(script)
  ------------------
  |  |  226|     43|  do {							\
  |  |  227|     43|    ar.tag(#f);						\
  |  |  228|     43|    bool r = do_serialize(ar, f);			\
  |  |  229|     43|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 43]
  |  |  |  Branch (229:15): [True: 0, False: 43]
  |  |  ------------------
  |  |  230|     43|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
   69|     43|    END_SERIALIZE()
  ------------------
  |  |  207|     43|  return ar.good();				\
  |  |  208|     43|  }
  ------------------
_ZN10cryptonote11txin_to_key19do_serialize_objectILb1E14binary_archiveEEbRT0_IXT_EE:
  144|     24|    BEGIN_SERIALIZE_OBJECT()
  ------------------
  |  |  184|     24|  bool do_serialize_object(Archive<W> &ar){
  ------------------
  145|     24|      VARINT_FIELD(amount)
  ------------------
  |  |  252|     24|  do {						\
  |  |  253|     24|    ar.tag(#f);					\
  |  |  254|     24|    ar.serialize_varint(f);			\
  |  |  255|     24|    if (!ar.good()) return false;		\
  |  |  ------------------
  |  |  |  Branch (255:9): [True: 0, False: 24]
  |  |  ------------------
  |  |  256|     24|  } while(0);
  |  |  ------------------
  |  |  |  Branch (256:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  146|     24|      FIELD(key_offsets)
  ------------------
  |  |  226|     24|  do {							\
  |  |  227|     24|    ar.tag(#f);						\
  |  |  228|     24|    bool r = do_serialize(ar, f);			\
  |  |  229|     24|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 24]
  |  |  |  Branch (229:15): [True: 0, False: 24]
  |  |  ------------------
  |  |  230|     24|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  147|     24|      FIELD(k_image)
  ------------------
  |  |  226|     24|  do {							\
  |  |  227|     24|    ar.tag(#f);						\
  |  |  228|     24|    bool r = do_serialize(ar, f);			\
  |  |  229|     24|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 24]
  |  |  |  Branch (229:15): [True: 0, False: 24]
  |  |  ------------------
  |  |  230|     24|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  148|     24|    END_SERIALIZE()
  ------------------
  |  |  207|     24|  return ar.good();				\
  |  |  208|     24|  }
  ------------------
_ZN10cryptonote6tx_out19do_serialize_objectILb1E14binary_archiveEEbRT0_IXT_EE:
  162|     71|    BEGIN_SERIALIZE_OBJECT()
  ------------------
  |  |  184|     71|  bool do_serialize_object(Archive<W> &ar){
  ------------------
  163|     71|      VARINT_FIELD(amount)
  ------------------
  |  |  252|     71|  do {						\
  |  |  253|     71|    ar.tag(#f);					\
  |  |  254|     71|    ar.serialize_varint(f);			\
  |  |  255|     71|    if (!ar.good()) return false;		\
  |  |  ------------------
  |  |  |  Branch (255:9): [True: 0, False: 71]
  |  |  ------------------
  |  |  256|     71|  } while(0);
  |  |  ------------------
  |  |  |  Branch (256:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  164|     71|      FIELD(target)
  ------------------
  |  |  226|     71|  do {							\
  |  |  227|     71|    ar.tag(#f);						\
  |  |  228|     71|    bool r = do_serialize(ar, f);			\
  |  |  229|     71|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 71]
  |  |  |  Branch (229:15): [True: 0, False: 71]
  |  |  ------------------
  |  |  230|     71|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  165|     71|    END_SERIALIZE()
  ------------------
  |  |  207|     71|  return ar.good();				\
  |  |  208|     71|  }
  ------------------
_ZN10cryptonote19txout_to_tagged_key19do_serialize_objectILb1E14binary_archiveEEbRT0_IXT_EE:
   93|      4|    BEGIN_SERIALIZE_OBJECT()
  ------------------
  |  |  184|      4|  bool do_serialize_object(Archive<W> &ar){
  ------------------
   94|      4|      FIELD(key)
  ------------------
  |  |  226|      4|  do {							\
  |  |  227|      4|    ar.tag(#f);						\
  |  |  228|      4|    bool r = do_serialize(ar, f);			\
  |  |  229|      4|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 4]
  |  |  |  Branch (229:15): [True: 0, False: 4]
  |  |  ------------------
  |  |  230|      4|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
   95|      4|      FIELD(view_tag)
  ------------------
  |  |  226|      4|  do {							\
  |  |  227|      4|    ar.tag(#f);						\
  |  |  228|      4|    bool r = do_serialize(ar, f);			\
  |  |  229|      4|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 4]
  |  |  |  Branch (229:15): [True: 0, False: 4]
  |  |  ------------------
  |  |  230|      4|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
   96|      4|    END_SERIALIZE()
  ------------------
  |  |  207|      4|  return ar.good();				\
  |  |  208|      4|  }
  ------------------
_ZN10cryptonote11transaction19do_serialize_objectILb1E14binary_archiveEEbRT0_IXT_EE:
  242|      2|    BEGIN_SERIALIZE_OBJECT()
  ------------------
  |  |  184|      2|  bool do_serialize_object(Archive<W> &ar){
  ------------------
  243|      2|      if (!typename Archive<W>::is_saving())
  ------------------
  |  Branch (243:11): [Folded - Ignored]
  ------------------
  244|      0|      {
  245|      0|        set_hash_valid(false);
  246|      0|        set_prunable_hash_valid(false);
  247|      0|        set_blob_size_valid(false);
  248|      0|      }
  249|       |
  250|      2|      const auto start_pos = ar.getpos();
  251|       |
  252|      2|      FIELDS(*static_cast<transaction_prefix *>(this))
  ------------------
  |  |  243|      2|  do {									\
  |  |  244|      2|    bool r = do_serialize(ar, f);					\
  |  |  245|      2|    if (!r || !ar.good()) return false;					\
  |  |  ------------------
  |  |  |  Branch (245:9): [True: 0, False: 2]
  |  |  |  Branch (245:15): [True: 0, False: 2]
  |  |  ------------------
  |  |  246|      2|  } while(0);
  |  |  ------------------
  |  |  |  Branch (246:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  253|       |
  254|      2|      if (std::is_same<Archive<W>, binary_archive<W>>())
  ------------------
  |  Branch (254:11): [Folded - Ignored]
  ------------------
  255|      2|        prefix_size = ar.getpos() - start_pos;
  256|       |
  257|      2|      if (version == 1)
  ------------------
  |  Branch (257:11): [True: 2, False: 0]
  ------------------
  258|      2|      {
  259|      2|        if (std::is_same<Archive<W>, binary_archive<W>>())
  ------------------
  |  Branch (259:13): [Folded - Ignored]
  ------------------
  260|      2|          unprunable_size = ar.getpos() - start_pos;
  261|       |
  262|      2|        ar.tag("signatures");
  263|      2|        ar.begin_array();
  264|      2|        PREPARE_CUSTOM_VECTOR_SERIALIZATION(vin.size(), signatures);
  ------------------
  |  |  201|      2|  ::serialization::detail::prepare_custom_vector_serialization(size, vec, typename Archive<W>::is_saving())
  ------------------
  265|      2|        bool signatures_not_expected = signatures.empty();
  266|      2|        if (!signatures_not_expected && vin.size() != signatures.size())
  ------------------
  |  Branch (266:13): [True: 2, False: 0]
  |  Branch (266:41): [True: 0, False: 2]
  ------------------
  267|      0|          return false;
  268|       |
  269|      4|        if (!pruned) for (size_t i = 0; i < vin.size(); ++i)
  ------------------
  |  Branch (269:13): [True: 2, False: 0]
  |  Branch (269:41): [True: 2, False: 2]
  ------------------
  270|      2|        {
  271|      2|          size_t signature_size = get_signature_size(vin[i]);
  272|      2|          if (signatures_not_expected)
  ------------------
  |  Branch (272:15): [True: 0, False: 2]
  ------------------
  273|      0|          {
  274|      0|            if (0 == signature_size)
  ------------------
  |  Branch (274:17): [True: 0, False: 0]
  ------------------
  275|      0|              continue;
  276|      0|            else
  277|      0|              return false;
  278|      0|          }
  279|       |
  280|      2|          PREPARE_CUSTOM_VECTOR_SERIALIZATION(signature_size, signatures[i]);
  ------------------
  |  |  201|      2|  ::serialization::detail::prepare_custom_vector_serialization(size, vec, typename Archive<W>::is_saving())
  ------------------
  281|      2|          if (signature_size != signatures[i].size())
  ------------------
  |  Branch (281:15): [True: 0, False: 2]
  ------------------
  282|      0|            return false;
  283|       |
  284|      2|          FIELDS(signatures[i]);
  ------------------
  |  |  243|      2|  do {									\
  |  |  244|      2|    bool r = do_serialize(ar, f);					\
  |  |  245|      2|    if (!r || !ar.good()) return false;					\
  |  |  ------------------
  |  |  |  Branch (245:9): [True: 0, False: 2]
  |  |  |  Branch (245:15): [True: 0, False: 2]
  |  |  ------------------
  |  |  246|      2|  } while(0);
  |  |  ------------------
  |  |  |  Branch (246:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  285|       |
  286|      2|          if (vin.size() - i > 1)
  ------------------
  |  Branch (286:15): [True: 0, False: 2]
  ------------------
  287|      0|            ar.delimit_array();
  288|      2|        }
  289|      2|        ar.end_array();
  290|      2|      }
  291|      0|      else
  292|      0|      {
  293|      0|        ar.tag("rct_signatures");
  294|      0|        if (!vin.empty())
  ------------------
  |  Branch (294:13): [True: 0, False: 0]
  ------------------
  295|      0|        {
  296|      0|          ar.begin_object();
  297|      0|          bool r = rct_signatures.serialize_rctsig_base(ar, vin.size(), vout.size());
  298|      0|          if (!r || !ar.good()) return false;
  ------------------
  |  Branch (298:15): [True: 0, False: 0]
  |  Branch (298:21): [True: 0, False: 0]
  ------------------
  299|      0|          ar.end_object();
  300|       |
  301|      0|          if (std::is_same<Archive<W>, binary_archive<W>>())
  ------------------
  |  Branch (301:15): [Folded - Ignored]
  ------------------
  302|      0|            unprunable_size = ar.getpos() - start_pos;
  303|       |
  304|      0|          if (!pruned && rct_signatures.type != rct::RCTTypeNull)
  ------------------
  |  Branch (304:15): [True: 0, False: 0]
  |  Branch (304:26): [True: 0, False: 0]
  ------------------
  305|      0|          {
  306|      0|            ar.tag("rctsig_prunable");
  307|      0|            ar.begin_object();
  308|      0|            r = rct_signatures.p.serialize_rctsig_prunable(ar, rct_signatures.type, vin.size(), vout.size(),
  309|      0|                vin.size() > 0 && vin[0].type() == typeid(txin_to_key) ? boost::get<txin_to_key>(vin[0]).key_offsets.size() - 1 : 0);
  ------------------
  |  Branch (309:17): [True: 0, False: 0]
  |  Branch (309:35): [True: 0, False: 0]
  ------------------
  310|      0|            if (!r || !ar.good()) return false;
  ------------------
  |  Branch (310:17): [True: 0, False: 0]
  |  Branch (310:23): [True: 0, False: 0]
  ------------------
  311|      0|            ar.end_object();
  312|      0|          }
  313|      0|        }
  314|      0|      }
  315|      2|      if (!typename Archive<W>::is_saving())
  ------------------
  |  Branch (315:11): [Folded - Ignored]
  ------------------
  316|      0|        pruned = false;
  317|      2|    END_SERIALIZE()
  ------------------
  |  |  207|      2|  return ar.good();				\
  |  |  208|      2|  }
  ------------------
_ZN10cryptonote11transaction19do_serialize_objectILb0E14binary_archiveEEbRT0_IXT_EE:
  242|      1|    BEGIN_SERIALIZE_OBJECT()
  ------------------
  |  |  184|      1|  bool do_serialize_object(Archive<W> &ar){
  ------------------
  243|      1|      if (!typename Archive<W>::is_saving())
  ------------------
  |  Branch (243:11): [Folded - Ignored]
  ------------------
  244|      1|      {
  245|      1|        set_hash_valid(false);
  246|      1|        set_prunable_hash_valid(false);
  247|      1|        set_blob_size_valid(false);
  248|      1|      }
  249|       |
  250|      1|      const auto start_pos = ar.getpos();
  251|       |
  252|      1|      FIELDS(*static_cast<transaction_prefix *>(this))
  ------------------
  |  |  243|      1|  do {									\
  |  |  244|      1|    bool r = do_serialize(ar, f);					\
  |  |  245|      1|    if (!r || !ar.good()) return false;					\
  |  |  ------------------
  |  |  |  Branch (245:9): [True: 0, False: 1]
  |  |  |  Branch (245:15): [True: 0, False: 1]
  |  |  ------------------
  |  |  246|      1|  } while(0);
  |  |  ------------------
  |  |  |  Branch (246:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  253|       |
  254|      1|      if (std::is_same<Archive<W>, binary_archive<W>>())
  ------------------
  |  Branch (254:11): [Folded - Ignored]
  ------------------
  255|      1|        prefix_size = ar.getpos() - start_pos;
  256|       |
  257|      1|      if (version == 1)
  ------------------
  |  Branch (257:11): [True: 1, False: 0]
  ------------------
  258|      1|      {
  259|      1|        if (std::is_same<Archive<W>, binary_archive<W>>())
  ------------------
  |  Branch (259:13): [Folded - Ignored]
  ------------------
  260|      1|          unprunable_size = ar.getpos() - start_pos;
  261|       |
  262|      1|        ar.tag("signatures");
  263|      1|        ar.begin_array();
  264|      1|        PREPARE_CUSTOM_VECTOR_SERIALIZATION(vin.size(), signatures);
  ------------------
  |  |  201|      1|  ::serialization::detail::prepare_custom_vector_serialization(size, vec, typename Archive<W>::is_saving())
  ------------------
  265|      1|        bool signatures_not_expected = signatures.empty();
  266|      1|        if (!signatures_not_expected && vin.size() != signatures.size())
  ------------------
  |  Branch (266:13): [True: 1, False: 0]
  |  Branch (266:41): [True: 0, False: 1]
  ------------------
  267|      0|          return false;
  268|       |
  269|      2|        if (!pruned) for (size_t i = 0; i < vin.size(); ++i)
  ------------------
  |  Branch (269:13): [True: 1, False: 0]
  |  Branch (269:41): [True: 1, False: 1]
  ------------------
  270|      1|        {
  271|      1|          size_t signature_size = get_signature_size(vin[i]);
  272|      1|          if (signatures_not_expected)
  ------------------
  |  Branch (272:15): [True: 0, False: 1]
  ------------------
  273|      0|          {
  274|      0|            if (0 == signature_size)
  ------------------
  |  Branch (274:17): [True: 0, False: 0]
  ------------------
  275|      0|              continue;
  276|      0|            else
  277|      0|              return false;
  278|      0|          }
  279|       |
  280|      1|          PREPARE_CUSTOM_VECTOR_SERIALIZATION(signature_size, signatures[i]);
  ------------------
  |  |  201|      1|  ::serialization::detail::prepare_custom_vector_serialization(size, vec, typename Archive<W>::is_saving())
  ------------------
  281|      1|          if (signature_size != signatures[i].size())
  ------------------
  |  Branch (281:15): [True: 0, False: 1]
  ------------------
  282|      0|            return false;
  283|       |
  284|      1|          FIELDS(signatures[i]);
  ------------------
  |  |  243|      1|  do {									\
  |  |  244|      1|    bool r = do_serialize(ar, f);					\
  |  |  245|      1|    if (!r || !ar.good()) return false;					\
  |  |  ------------------
  |  |  |  Branch (245:9): [True: 0, False: 1]
  |  |  |  Branch (245:15): [True: 0, False: 1]
  |  |  ------------------
  |  |  246|      1|  } while(0);
  |  |  ------------------
  |  |  |  Branch (246:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  285|       |
  286|      1|          if (vin.size() - i > 1)
  ------------------
  |  Branch (286:15): [True: 0, False: 1]
  ------------------
  287|      0|            ar.delimit_array();
  288|      1|        }
  289|      1|        ar.end_array();
  290|      1|      }
  291|      0|      else
  292|      0|      {
  293|      0|        ar.tag("rct_signatures");
  294|      0|        if (!vin.empty())
  ------------------
  |  Branch (294:13): [True: 0, False: 0]
  ------------------
  295|      0|        {
  296|      0|          ar.begin_object();
  297|      0|          bool r = rct_signatures.serialize_rctsig_base(ar, vin.size(), vout.size());
  298|      0|          if (!r || !ar.good()) return false;
  ------------------
  |  Branch (298:15): [True: 0, False: 0]
  |  Branch (298:21): [True: 0, False: 0]
  ------------------
  299|      0|          ar.end_object();
  300|       |
  301|      0|          if (std::is_same<Archive<W>, binary_archive<W>>())
  ------------------
  |  Branch (301:15): [Folded - Ignored]
  ------------------
  302|      0|            unprunable_size = ar.getpos() - start_pos;
  303|       |
  304|      0|          if (!pruned && rct_signatures.type != rct::RCTTypeNull)
  ------------------
  |  Branch (304:15): [True: 0, False: 0]
  |  Branch (304:26): [True: 0, False: 0]
  ------------------
  305|      0|          {
  306|      0|            ar.tag("rctsig_prunable");
  307|      0|            ar.begin_object();
  308|      0|            r = rct_signatures.p.serialize_rctsig_prunable(ar, rct_signatures.type, vin.size(), vout.size(),
  309|      0|                vin.size() > 0 && vin[0].type() == typeid(txin_to_key) ? boost::get<txin_to_key>(vin[0]).key_offsets.size() - 1 : 0);
  ------------------
  |  Branch (309:17): [True: 0, False: 0]
  |  Branch (309:35): [True: 0, False: 0]
  ------------------
  310|      0|            if (!r || !ar.good()) return false;
  ------------------
  |  Branch (310:17): [True: 0, False: 0]
  |  Branch (310:23): [True: 0, False: 0]
  ------------------
  311|      0|            ar.end_object();
  312|      0|          }
  313|      0|        }
  314|      0|      }
  315|      1|      if (!typename Archive<W>::is_saving())
  ------------------
  |  Branch (315:11): [Folded - Ignored]
  ------------------
  316|      1|        pruned = false;
  317|      1|    END_SERIALIZE()
  ------------------
  |  |  207|      1|  return ar.good();				\
  |  |  208|      1|  }
  ------------------
_ZN10cryptonote12block_header19member_do_serializeILb1E14binary_archiveEEbRT0_IXT_EE:
  465|      3|    BEGIN_SERIALIZE()
  ------------------
  |  |  157|      3|  bool member_do_serialize(Archive<W> &ar) {
  ------------------
  466|      3|      VARINT_FIELD(major_version)
  ------------------
  |  |  252|      3|  do {						\
  |  |  253|      3|    ar.tag(#f);					\
  |  |  254|      3|    ar.serialize_varint(f);			\
  |  |  255|      3|    if (!ar.good()) return false;		\
  |  |  ------------------
  |  |  |  Branch (255:9): [True: 0, False: 3]
  |  |  ------------------
  |  |  256|      3|  } while(0);
  |  |  ------------------
  |  |  |  Branch (256:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  467|      3|      VARINT_FIELD(minor_version)
  ------------------
  |  |  252|      3|  do {						\
  |  |  253|      3|    ar.tag(#f);					\
  |  |  254|      3|    ar.serialize_varint(f);			\
  |  |  255|      3|    if (!ar.good()) return false;		\
  |  |  ------------------
  |  |  |  Branch (255:9): [True: 0, False: 3]
  |  |  ------------------
  |  |  256|      3|  } while(0);
  |  |  ------------------
  |  |  |  Branch (256:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  468|      3|      VARINT_FIELD(timestamp)
  ------------------
  |  |  252|      3|  do {						\
  |  |  253|      3|    ar.tag(#f);					\
  |  |  254|      3|    ar.serialize_varint(f);			\
  |  |  255|      3|    if (!ar.good()) return false;		\
  |  |  ------------------
  |  |  |  Branch (255:9): [True: 0, False: 3]
  |  |  ------------------
  |  |  256|      3|  } while(0);
  |  |  ------------------
  |  |  |  Branch (256:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  469|      3|      FIELD(prev_id)
  ------------------
  |  |  226|      3|  do {							\
  |  |  227|      3|    ar.tag(#f);						\
  |  |  228|      3|    bool r = do_serialize(ar, f);			\
  |  |  229|      3|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 3]
  |  |  |  Branch (229:15): [True: 0, False: 3]
  |  |  ------------------
  |  |  230|      3|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  470|      3|      FIELD(nonce)
  ------------------
  |  |  226|      3|  do {							\
  |  |  227|      3|    ar.tag(#f);						\
  |  |  228|      3|    bool r = do_serialize(ar, f);			\
  |  |  229|      3|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 3]
  |  |  |  Branch (229:15): [True: 0, False: 3]
  |  |  ------------------
  |  |  230|      3|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  471|      3|    END_SERIALIZE()
  ------------------
  |  |  207|      3|  return ar.good();				\
  |  |  208|      3|  }
  ------------------
_ZN10cryptonote5block19do_serialize_objectILb1E14binary_archiveEEbRT0_IXT_EE:
  495|      1|    BEGIN_SERIALIZE_OBJECT()
  ------------------
  |  |  184|      1|  bool do_serialize_object(Archive<W> &ar){
  ------------------
  496|      1|      if (!typename Archive<W>::is_saving())
  ------------------
  |  Branch (496:11): [Folded - Ignored]
  ------------------
  497|      0|        set_hash_valid(false);
  498|       |
  499|      1|      FIELDS(*static_cast<block_header *>(this))
  ------------------
  |  |  243|      1|  do {									\
  |  |  244|      1|    bool r = do_serialize(ar, f);					\
  |  |  245|      1|    if (!r || !ar.good()) return false;					\
  |  |  ------------------
  |  |  |  Branch (245:9): [True: 0, False: 1]
  |  |  |  Branch (245:15): [True: 0, False: 1]
  |  |  ------------------
  |  |  246|      1|  } while(0);
  |  |  ------------------
  |  |  |  Branch (246:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  500|      1|      FIELD(miner_tx)
  ------------------
  |  |  226|      1|  do {							\
  |  |  227|      1|    ar.tag(#f);						\
  |  |  228|      1|    bool r = do_serialize(ar, f);			\
  |  |  229|      1|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 1]
  |  |  |  Branch (229:15): [True: 0, False: 1]
  |  |  ------------------
  |  |  230|      1|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  501|      1|      FIELD(tx_hashes)
  ------------------
  |  |  226|      1|  do {							\
  |  |  227|      1|    ar.tag(#f);						\
  |  |  228|      1|    bool r = do_serialize(ar, f);			\
  |  |  229|      1|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 1]
  |  |  |  Branch (229:15): [True: 0, False: 1]
  |  |  ------------------
  |  |  230|      1|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  502|      1|      if (tx_hashes.size() > CRYPTONOTE_MAX_TX_PER_BLOCK)
  ------------------
  |  |   42|      1|#define CRYPTONOTE_MAX_TX_PER_BLOCK                     0x10000000
  ------------------
  |  Branch (502:11): [True: 0, False: 1]
  ------------------
  503|      0|        return false;
  504|      1|    END_SERIALIZE()
  ------------------
  |  |  207|      1|  return ar.good();				\
  |  |  208|      1|  }
  ------------------

_ZN10cryptonote20expand_transaction_1ERNS_11transactionEb:
  122|      1|  {
  123|      1|    if (tx.version >= 2 && !is_coinbase(tx))
  ------------------
  |  Branch (123:9): [True: 0, False: 1]
  |  Branch (123:28): [True: 0, False: 0]
  ------------------
  124|      0|    {
  125|      0|      rct::rctSig &rv = tx.rct_signatures;
  126|      0|      if (rv.type == rct::RCTTypeNull)
  ------------------
  |  Branch (126:11): [True: 0, False: 0]
  ------------------
  127|      0|        return true;
  128|      0|      if (rv.outPk.size() != tx.vout.size())
  ------------------
  |  Branch (128:11): [True: 0, False: 0]
  ------------------
  129|      0|      {
  130|      0|        LOG_PRINT_L1("Failed to parse transaction from blob, bad outPk size in tx " << get_transaction_hash(tx));
  ------------------
  |  |  102|      0|#define LOG_PRINT_L1(x) MINFO(x)
  |  |  ------------------
  |  |  |  |   77|      0|#define MINFO(x) MCINFO(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|      0|#define MCINFO(cat,x) MCLOG(el::Level::Info,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  131|      0|        return false;
  132|      0|      }
  133|      0|      for (size_t n = 0; n < tx.rct_signatures.outPk.size(); ++n)
  ------------------
  |  Branch (133:26): [True: 0, False: 0]
  ------------------
  134|      0|      {
  135|      0|        crypto::public_key output_public_key;
  136|      0|        if (!get_output_public_key(tx.vout[n], output_public_key))
  ------------------
  |  Branch (136:13): [True: 0, False: 0]
  ------------------
  137|      0|        {
  138|      0|          LOG_PRINT_L1("Failed to get output public key for output " << n << " in tx " << get_transaction_hash(tx));
  ------------------
  |  |  102|      0|#define LOG_PRINT_L1(x) MINFO(x)
  |  |  ------------------
  |  |  |  |   77|      0|#define MINFO(x) MCINFO(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|      0|#define MCINFO(cat,x) MCLOG(el::Level::Info,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  139|      0|          return false;
  140|      0|        }
  141|      0|        rv.outPk[n].dest = rct::pk2rct(output_public_key);
  142|      0|      }
  143|       |
  144|      0|      if (!base_only)
  ------------------
  |  Branch (144:11): [True: 0, False: 0]
  ------------------
  145|      0|      {
  146|      0|        const bool bulletproof = rct::is_rct_bulletproof(rv.type);
  147|      0|        const bool bulletproof_plus = rct::is_rct_bulletproof_plus(rv.type);
  148|      0|        if (bulletproof_plus)
  ------------------
  |  Branch (148:13): [True: 0, False: 0]
  ------------------
  149|      0|        {
  150|      0|          if (rv.p.bulletproofs_plus.size() != 1)
  ------------------
  |  Branch (150:15): [True: 0, False: 0]
  ------------------
  151|      0|          {
  152|      0|            LOG_PRINT_L1("Failed to parse transaction from blob, bad bulletproofs_plus size in tx " << get_transaction_hash(tx));
  ------------------
  |  |  102|      0|#define LOG_PRINT_L1(x) MINFO(x)
  |  |  ------------------
  |  |  |  |   77|      0|#define MINFO(x) MCINFO(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|      0|#define MCINFO(cat,x) MCLOG(el::Level::Info,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  153|      0|            return false;
  154|      0|          }
  155|      0|          if (rv.p.bulletproofs_plus[0].L.size() < 6)
  ------------------
  |  Branch (155:15): [True: 0, False: 0]
  ------------------
  156|      0|          {
  157|      0|            LOG_PRINT_L1("Failed to parse transaction from blob, bad bulletproofs_plus L size in tx " << get_transaction_hash(tx));
  ------------------
  |  |  102|      0|#define LOG_PRINT_L1(x) MINFO(x)
  |  |  ------------------
  |  |  |  |   77|      0|#define MINFO(x) MCINFO(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|      0|#define MCINFO(cat,x) MCLOG(el::Level::Info,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  158|      0|            return false;
  159|      0|          }
  160|      0|          const size_t max_outputs = rct::n_bulletproof_plus_max_amounts(rv.p.bulletproofs_plus[0]);
  161|      0|          if (max_outputs < tx.vout.size())
  ------------------
  |  Branch (161:15): [True: 0, False: 0]
  ------------------
  162|      0|          {
  163|      0|            LOG_PRINT_L1("Failed to parse transaction from blob, bad bulletproofs_plus max outputs in tx " << get_transaction_hash(tx));
  ------------------
  |  |  102|      0|#define LOG_PRINT_L1(x) MINFO(x)
  |  |  ------------------
  |  |  |  |   77|      0|#define MINFO(x) MCINFO(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|      0|#define MCINFO(cat,x) MCLOG(el::Level::Info,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  164|      0|            return false;
  165|      0|          }
  166|      0|          const size_t n_amounts = tx.vout.size();
  167|      0|          CHECK_AND_ASSERT_MES(n_amounts == rv.outPk.size(), false, "Internal error filling out V");
  ------------------
  |  |  183|      0|#define CHECK_AND_ASSERT_MES(expr, fail_ret_val, message)   do{if(!(expr)) {LOG_ERROR(message); return fail_ret_val;};}while(0)
  |  |  ------------------
  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (183:67): [True: 0, False: 0]
  |  |  |  Branch (183:126): [Folded - Ignored]
  |  |  ------------------
  ------------------
  168|      0|          rv.p.bulletproofs_plus[0].V.resize(n_amounts);
  169|      0|          for (size_t i = 0; i < n_amounts; ++i)
  ------------------
  |  Branch (169:30): [True: 0, False: 0]
  ------------------
  170|      0|            rv.p.bulletproofs_plus[0].V[i] = rct::scalarmultKey(rv.outPk[i].mask, rct::INV_EIGHT);
  171|      0|        }
  172|      0|        else if (bulletproof)
  ------------------
  |  Branch (172:18): [True: 0, False: 0]
  ------------------
  173|      0|        {
  174|      0|          if (rv.p.bulletproofs.size() != 1)
  ------------------
  |  Branch (174:15): [True: 0, False: 0]
  ------------------
  175|      0|          {
  176|      0|            LOG_PRINT_L1("Failed to parse transaction from blob, bad bulletproofs size in tx " << get_transaction_hash(tx));
  ------------------
  |  |  102|      0|#define LOG_PRINT_L1(x) MINFO(x)
  |  |  ------------------
  |  |  |  |   77|      0|#define MINFO(x) MCINFO(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|      0|#define MCINFO(cat,x) MCLOG(el::Level::Info,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  177|      0|            return false;
  178|      0|          }
  179|      0|          if (rv.p.bulletproofs[0].L.size() < 6)
  ------------------
  |  Branch (179:15): [True: 0, False: 0]
  ------------------
  180|      0|          {
  181|      0|            LOG_PRINT_L1("Failed to parse transaction from blob, bad bulletproofs L size in tx " << get_transaction_hash(tx));
  ------------------
  |  |  102|      0|#define LOG_PRINT_L1(x) MINFO(x)
  |  |  ------------------
  |  |  |  |   77|      0|#define MINFO(x) MCINFO(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|      0|#define MCINFO(cat,x) MCLOG(el::Level::Info,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  182|      0|            return false;
  183|      0|          }
  184|      0|          const size_t max_outputs = 1 << (rv.p.bulletproofs[0].L.size() - 6);
  185|      0|          if (max_outputs < tx.vout.size())
  ------------------
  |  Branch (185:15): [True: 0, False: 0]
  ------------------
  186|      0|          {
  187|      0|            LOG_PRINT_L1("Failed to parse transaction from blob, bad bulletproofs max outputs in tx " << get_transaction_hash(tx));
  ------------------
  |  |  102|      0|#define LOG_PRINT_L1(x) MINFO(x)
  |  |  ------------------
  |  |  |  |   77|      0|#define MINFO(x) MCINFO(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|      0|#define MCINFO(cat,x) MCLOG(el::Level::Info,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  188|      0|            return false;
  189|      0|          }
  190|      0|          const size_t n_amounts = tx.vout.size();
  191|      0|          CHECK_AND_ASSERT_MES(n_amounts == rv.outPk.size(), false, "Internal error filling out V");
  ------------------
  |  |  183|      0|#define CHECK_AND_ASSERT_MES(expr, fail_ret_val, message)   do{if(!(expr)) {LOG_ERROR(message); return fail_ret_val;};}while(0)
  |  |  ------------------
  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (183:67): [True: 0, False: 0]
  |  |  |  Branch (183:126): [Folded - Ignored]
  |  |  ------------------
  ------------------
  192|      0|          rv.p.bulletproofs[0].V.resize(n_amounts);
  193|      0|          for (size_t i = 0; i < n_amounts; ++i)
  ------------------
  |  Branch (193:30): [True: 0, False: 0]
  ------------------
  194|      0|            rv.p.bulletproofs[0].V[i] = rct::scalarmultKey(rv.outPk[i].mask, rct::INV_EIGHT);
  195|      0|        }
  196|      0|      }
  197|      0|    }
  198|      1|    return true;
  199|      1|  }
_ZN10cryptonote31parse_and_validate_tx_from_blobERKN5boost16basic_string_refIcNSt3__111char_traitsIcEEEERNS_11transactionE:
  202|      1|  {
  203|      1|    binary_archive<false> ba{epee::strspan<std::uint8_t>(tx_blob)};
  204|      1|    bool r = ::serialization::serialize(ba, tx);
  205|      1|    CHECK_AND_ASSERT_MES(r, false, "Failed to parse transaction from blob");
  ------------------
  |  |  183|      1|#define CHECK_AND_ASSERT_MES(expr, fail_ret_val, message)   do{if(!(expr)) {LOG_ERROR(message); return fail_ret_val;};}while(0)
  |  |  ------------------
  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (183:67): [True: 0, False: 1]
  |  |  |  Branch (183:126): [Folded - Ignored]
  |  |  ------------------
  ------------------
  206|      1|    CHECK_AND_ASSERT_MES(expand_transaction_1(tx, false), false, "Failed to expand transaction data");
  ------------------
  |  |  183|      1|#define CHECK_AND_ASSERT_MES(expr, fail_ret_val, message)   do{if(!(expr)) {LOG_ERROR(message); return fail_ret_val;};}while(0)
  |  |  ------------------
  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (183:67): [True: 0, False: 1]
  |  |  |  Branch (183:126): [Folded - Ignored]
  |  |  ------------------
  ------------------
  207|      1|    tx.invalidate_hashes();
  208|      1|    tx.set_blob_size(tx_blob.size());
  209|      1|    return true;
  210|      1|  }
_ZN10cryptonote25generate_key_image_helperERKNS_12account_keysERKNSt3__113unordered_mapIN6crypto10public_keyENS_16subaddress_indexENS3_4hashIS6_EENS3_8equal_toIS6_EENS3_9allocatorINS3_4pairIKS6_S7_EEEEEERSE_SK_RKNS3_6vectorIS6_NSC_IS6_EEEEmRNS_7keypairERNS5_9key_imageERN2hw6deviceE:
  267|  2.36k|  {
  268|  2.36k|    crypto::key_derivation recv_derivation = AUTO_VAL_INIT(recv_derivation);
  ------------------
  |  |   36|  2.36k|#define AUTO_VAL_INIT(v)   boost::value_initialized<decltype(v)>()
  ------------------
  269|  2.36k|    bool r = hwdev.generate_key_derivation(tx_public_key, ack.m_view_secret_key, recv_derivation);
  270|  2.36k|    if (!r)
  ------------------
  |  Branch (270:9): [True: 1.03k, False: 1.33k]
  ------------------
  271|  1.03k|    {
  272|  1.03k|      MWARNING("key image helper: failed to generate_key_derivation(" << tx_public_key << ", <viewkey>)");
  ------------------
  |  |   76|  1.03k|#define MWARNING(x) MCWARNING(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  ------------------
  |  |  |  |   54|  1.03k|#define MCWARNING(cat,x) MCLOG(el::Level::Warning,cat, el::Color::Default, x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|  1.03k|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   43|  1.03k|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |   44|  1.03k|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 1.03k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |   47|  1.03k|  } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  273|  1.03k|      memcpy(&recv_derivation, rct::identity().bytes, sizeof(recv_derivation));
  274|  1.03k|    }
  275|       |
  276|  2.36k|    std::vector<crypto::key_derivation> additional_recv_derivations;
  277|   124k|    for (size_t i = 0; i < additional_tx_public_keys.size(); ++i)
  ------------------
  |  Branch (277:24): [True: 122k, False: 2.36k]
  ------------------
  278|   122k|    {
  279|   122k|      crypto::key_derivation additional_recv_derivation = AUTO_VAL_INIT(additional_recv_derivation);
  ------------------
  |  |   36|   122k|#define AUTO_VAL_INIT(v)   boost::value_initialized<decltype(v)>()
  ------------------
  280|   122k|      r = hwdev.generate_key_derivation(additional_tx_public_keys[i], ack.m_view_secret_key, additional_recv_derivation);
  281|   122k|      if (!r)
  ------------------
  |  Branch (281:11): [True: 37.3k, False: 84.6k]
  ------------------
  282|  37.3k|      {
  283|  37.3k|        MWARNING("key image helper: failed to generate_key_derivation(" << additional_tx_public_keys[i] << ", <viewkey>)");
  ------------------
  |  |   76|  37.3k|#define MWARNING(x) MCWARNING(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  ------------------
  |  |  |  |   54|  37.3k|#define MCWARNING(cat,x) MCLOG(el::Level::Warning,cat, el::Color::Default, x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|  37.3k|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   43|  37.3k|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |   44|  37.3k|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 37.3k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |   47|  37.3k|  } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  284|  37.3k|      }
  285|  84.6k|      else
  286|  84.6k|      {
  287|  84.6k|        additional_recv_derivations.push_back(additional_recv_derivation);
  288|  84.6k|      }
  289|   122k|    }
  290|       |
  291|  2.36k|    boost::optional<subaddress_receive_info> subaddr_recv_info = is_out_to_acc_precomp(subaddresses, out_key, recv_derivation, additional_recv_derivations, real_output_index,hwdev);
  292|  2.36k|    CHECK_AND_ASSERT_MES(subaddr_recv_info, false, "key image helper: given output pubkey doesn't seem to belong to this address");
  ------------------
  |  |  183|  2.36k|#define CHECK_AND_ASSERT_MES(expr, fail_ret_val, message)   do{if(!(expr)) {LOG_ERROR(message); return fail_ret_val;};}while(0)
  |  |  ------------------
  |  |  |  |  100|  2.36k|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|  2.36k|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|  2.36k|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|  2.36k|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|  2.36k|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|  2.36k|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 2.36k]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|  2.36k|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (183:67): [True: 2.36k, False: 1]
  |  |  |  Branch (183:126): [Folded - Ignored]
  |  |  ------------------
  ------------------
  293|       |
  294|      1|    return generate_key_image_helper_precomp(ack, out_key, subaddr_recv_info->derivation, real_output_index, subaddr_recv_info->index, in_ephemeral, ki, hwdev);
  295|  2.36k|  }
_ZN10cryptonote33generate_key_image_helper_precompERKNS_12account_keysERKN6crypto10public_keyERKNS3_14key_derivationEmRKNS_16subaddress_indexERNS_7keypairERNS3_9key_imageERN2hw6deviceE:
  298|      1|  {
  299|      1|    if (hwdev.compute_key_image(ack, out_key, recv_derivation, real_output_index, received_index, in_ephemeral, ki))
  ------------------
  |  Branch (299:9): [True: 0, False: 1]
  ------------------
  300|      0|    {
  301|      0|      return true;
  302|      0|    }
  303|       |
  304|      1|    if (ack.m_spend_secret_key == crypto::null_skey)
  ------------------
  |  Branch (304:9): [True: 0, False: 1]
  ------------------
  305|      0|    {
  306|       |      // for watch-only wallet, simply copy the known output pubkey
  307|      0|      in_ephemeral.pub = out_key;
  308|      0|      in_ephemeral.sec = crypto::null_skey;
  309|      0|    }
  310|      1|    else
  311|      1|    {
  312|       |      // derive secret key with subaddress - step 1: original CN derivation
  313|      1|      crypto::secret_key scalar_step1;
  314|      1|      crypto::secret_key spend_skey = crypto::null_skey;
  315|       |
  316|      1|      if (ack.m_multisig_keys.empty())
  ------------------
  |  Branch (316:11): [True: 1, False: 0]
  ------------------
  317|      1|      {
  318|       |        // if not multisig, use normal spend skey
  319|      1|        spend_skey = ack.m_spend_secret_key;
  320|      1|      }
  321|      0|      else
  322|      0|      {
  323|       |        // if multisig, use sum of multisig privkeys (local account's share of aggregate spend key)
  324|      0|        for (const auto &multisig_key : ack.m_multisig_keys)
  ------------------
  |  Branch (324:39): [True: 0, False: 0]
  ------------------
  325|      0|        {
  326|      0|          sc_add((unsigned char*)spend_skey.data,
  327|      0|            (const unsigned char*)multisig_key.data,
  328|      0|            (const unsigned char*)spend_skey.data);
  329|      0|        }
  330|      0|      }
  331|       |
  332|       |      // computes Hs(a*R || idx) + b
  333|      1|      hwdev.derive_secret_key(recv_derivation, real_output_index, spend_skey, scalar_step1);
  334|       |
  335|       |      // step 2: add Hs(a || index_major || index_minor)
  336|      1|      crypto::secret_key subaddr_sk;
  337|      1|      crypto::secret_key scalar_step2;
  338|      1|      if (received_index.is_zero())
  ------------------
  |  Branch (338:11): [True: 1, False: 0]
  ------------------
  339|      1|      {
  340|      1|        scalar_step2 = scalar_step1;    // treat index=(0,0) as a special case representing the main address
  341|      1|      }
  342|      0|      else
  343|      0|      {
  344|      0|        subaddr_sk = hwdev.get_subaddress_secret_key(ack.m_view_secret_key, received_index);
  345|      0|        hwdev.sc_secret_add(scalar_step2, scalar_step1,subaddr_sk);
  346|      0|      }
  347|       |
  348|      1|      in_ephemeral.sec = scalar_step2;
  349|       |
  350|      1|      if (ack.m_multisig_keys.empty())
  ------------------
  |  Branch (350:11): [True: 1, False: 0]
  ------------------
  351|      1|      {
  352|       |        // when not in multisig, we know the full spend secret key, so the output pubkey can be obtained by scalarmultBase
  353|      1|        CHECK_AND_ASSERT_MES(hwdev.secret_key_to_public_key(in_ephemeral.sec, in_ephemeral.pub), false, "Failed to derive public key");
  ------------------
  |  |  183|      1|#define CHECK_AND_ASSERT_MES(expr, fail_ret_val, message)   do{if(!(expr)) {LOG_ERROR(message); return fail_ret_val;};}while(0)
  |  |  ------------------
  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (183:67): [True: 0, False: 1]
  |  |  |  Branch (183:126): [Folded - Ignored]
  |  |  ------------------
  ------------------
  354|      1|      }
  355|      0|      else
  356|      0|      {
  357|       |        // when in multisig, we only know the partial spend secret key. but we do know the full spend public key, so the output pubkey can be obtained by using the standard CN key derivation
  358|      0|        CHECK_AND_ASSERT_MES(hwdev.derive_public_key(recv_derivation, real_output_index, ack.m_account_address.m_spend_public_key, in_ephemeral.pub), false, "Failed to derive public key");
  ------------------
  |  |  183|      0|#define CHECK_AND_ASSERT_MES(expr, fail_ret_val, message)   do{if(!(expr)) {LOG_ERROR(message); return fail_ret_val;};}while(0)
  |  |  ------------------
  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (183:67): [True: 0, False: 0]
  |  |  |  Branch (183:126): [Folded - Ignored]
  |  |  ------------------
  ------------------
  359|       |        // and don't forget to add the contribution from the subaddress part
  360|      0|        if (!received_index.is_zero())
  ------------------
  |  Branch (360:13): [True: 0, False: 0]
  ------------------
  361|      0|        {
  362|      0|          crypto::public_key subaddr_pk;
  363|      0|          CHECK_AND_ASSERT_MES(hwdev.secret_key_to_public_key(subaddr_sk, subaddr_pk), false, "Failed to derive public key");
  ------------------
  |  |  183|      0|#define CHECK_AND_ASSERT_MES(expr, fail_ret_val, message)   do{if(!(expr)) {LOG_ERROR(message); return fail_ret_val;};}while(0)
  |  |  ------------------
  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (183:67): [True: 0, False: 0]
  |  |  |  Branch (183:126): [Folded - Ignored]
  |  |  ------------------
  ------------------
  364|      0|          add_public_key(in_ephemeral.pub, in_ephemeral.pub, subaddr_pk);
  365|      0|        }
  366|      0|      }
  367|       |
  368|      1|      CHECK_AND_ASSERT_MES(in_ephemeral.pub == out_key,
  ------------------
  |  |  183|      1|#define CHECK_AND_ASSERT_MES(expr, fail_ret_val, message)   do{if(!(expr)) {LOG_ERROR(message); return fail_ret_val;};}while(0)
  |  |  ------------------
  |  |  |  |  100|      1|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      1|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|      1|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|      1|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|      1|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|      1|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 1]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|      1|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (183:67): [True: 1, False: 0]
  |  |  |  Branch (183:126): [Folded - Ignored]
  |  |  ------------------
  ------------------
  369|      1|           false, "key image helper precomp: given output pubkey doesn't match the derived one");
  370|      1|    }
  371|       |
  372|      0|    hwdev.generate_key_image(in_ephemeral.pub, in_ephemeral.sec, ki);
  373|      0|    return true;
  374|      1|  }
_ZN10cryptonote14parse_tx_extraERKNSt3__16vectorIhNS0_9allocatorIhEEEERNS1_IN5boost7variantINS_16tx_extra_paddingEJNS_16tx_extra_pub_keyENS_14tx_extra_nonceENS_25tx_extra_merge_mining_tagENS_28tx_extra_additional_pub_keysENS_29tx_extra_mysterious_minergateEEEENS2_ISF_EEEE:
  531|  2.44k|  {
  532|  2.44k|    tx_extra_fields.clear();
  533|       |
  534|  2.44k|    if(tx_extra.empty())
  ------------------
  |  Branch (534:8): [True: 1.22k, False: 1.21k]
  ------------------
  535|  1.22k|      return true;
  536|       |
  537|  1.21k|    binary_archive<false> ar{epee::to_span(tx_extra)};
  538|       |
  539|  1.21k|    do
  540|  17.8k|    {
  541|  17.8k|      tx_extra_field field;
  542|  17.8k|      bool r = ::do_serialize(ar, field);
  543|  17.8k|      CHECK_AND_NO_ASSERT_MES_L1(r, false, "failed to deserialize extra field. extra = " << string_tools::buff_to_hex_nodelimer(std::string(reinterpret_cast<const char*>(tx_extra.data()), tx_extra.size())));
  ------------------
  |  |  195|  17.8k|#define CHECK_AND_NO_ASSERT_MES_L1(expr, fail_ret_val, message) CHECK_AND_NO_ASSERT_MES_L(expr, fail_ret_val, 1, message)
  |  |  ------------------
  |  |  |  |  187|  17.8k|#define CHECK_AND_NO_ASSERT_MES_L(expr, fail_ret_val, l, message)   do{if(!(expr)) {LOG_PRINT_L##l(message); /*LOCAL_ASSERT(expr);*/ return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (187:75): [True: 590, False: 17.2k]
  |  |  |  |  |  Branch (187:163): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  544|  17.2k|      tx_extra_fields.push_back(field);
  545|  17.2k|    } while (!ar.eof());
  ------------------
  |  Branch (545:14): [True: 16.6k, False: 627]
  ------------------
  546|    627|    CHECK_AND_NO_ASSERT_MES_L1(::serialization::check_stream_state(ar), false, "failed to deserialize extra field. extra = " << string_tools::buff_to_hex_nodelimer(std::string(reinterpret_cast<const char*>(tx_extra.data()), tx_extra.size())));
  ------------------
  |  |  195|    627|#define CHECK_AND_NO_ASSERT_MES_L1(expr, fail_ret_val, message) CHECK_AND_NO_ASSERT_MES_L(expr, fail_ret_val, 1, message)
  |  |  ------------------
  |  |  |  |  187|    627|#define CHECK_AND_NO_ASSERT_MES_L(expr, fail_ret_val, l, message)   do{if(!(expr)) {LOG_PRINT_L##l(message); /*LOCAL_ASSERT(expr);*/ return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (187:75): [True: 0, False: 627]
  |  |  |  |  |  Branch (187:163): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  547|       |
  548|    627|    return true;
  549|    627|  }
_ZN10cryptonote23add_tx_pub_key_to_extraERNS_18transaction_prefixERKN6crypto10public_keyE:
  657|    897|  {
  658|    897|    return add_tx_pub_key_to_extra(tx.extra, tx_pub_key);
  659|    897|  }
_ZN10cryptonote23add_tx_pub_key_to_extraERNSt3__16vectorIhNS0_9allocatorIhEEEERKN6crypto10public_keyE:
  662|    897|  {
  663|    897|    tx_extra.resize(tx_extra.size() + 1 + sizeof(crypto::public_key));
  664|    897|    tx_extra[tx_extra.size() - 1 - sizeof(crypto::public_key)] = TX_EXTRA_TAG_PUBKEY;
  ------------------
  |  |   38|    897|#define TX_EXTRA_TAG_PUBKEY                 0x01
  ------------------
  665|    897|    *reinterpret_cast<crypto::public_key*>(&tx_extra[tx_extra.size() - sizeof(crypto::public_key)]) = tx_pub_key;
  666|    897|    return true;
  667|    897|  }
_ZN10cryptonote37get_additional_tx_pub_keys_from_extraERKNSt3__16vectorIhNS0_9allocatorIhEEEE:
  670|    427|  {
  671|       |    // parse
  672|    427|    std::vector<tx_extra_field> tx_extra_fields;
  673|    427|    parse_tx_extra(tx_extra, tx_extra_fields);
  674|       |    // find corresponding field
  675|    427|    tx_extra_additional_pub_keys additional_pub_keys;
  676|    427|    if(!find_tx_extra_field_by_type(tx_extra_fields, additional_pub_keys))
  ------------------
  |  Branch (676:8): [True: 398, False: 29]
  ------------------
  677|    398|      return {};
  678|     29|    return additional_pub_keys.data;
  679|    427|  }
_ZN10cryptonote37get_additional_tx_pub_keys_from_extraERKNS_18transaction_prefixE:
  682|    427|  {
  683|    427|    return get_additional_tx_pub_keys_from_extra(tx.extra);
  684|    427|  }
_ZN10cryptonote35add_additional_tx_pub_keys_to_extraERNSt3__16vectorIhNS0_9allocatorIhEEEERKNS1_IN6crypto10public_keyENS2_IS7_EEEE:
  687|    178|  {
  688|       |    // convert to variant
  689|    178|    tx_extra_field field = tx_extra_additional_pub_keys{ additional_pub_keys };
  690|       |    // serialize
  691|    178|    std::ostringstream oss;
  692|    178|    binary_archive<true> ar(oss);
  693|    178|    bool r = ::do_serialize(ar, field);
  694|    178|    CHECK_AND_NO_ASSERT_MES_L1(r, false, "failed to serialize tx extra additional tx pub keys");
  ------------------
  |  |  195|    178|#define CHECK_AND_NO_ASSERT_MES_L1(expr, fail_ret_val, message) CHECK_AND_NO_ASSERT_MES_L(expr, fail_ret_val, 1, message)
  |  |  ------------------
  |  |  |  |  187|    178|#define CHECK_AND_NO_ASSERT_MES_L(expr, fail_ret_val, l, message)   do{if(!(expr)) {LOG_PRINT_L##l(message); /*LOCAL_ASSERT(expr);*/ return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (187:75): [True: 0, False: 178]
  |  |  |  |  |  Branch (187:163): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  695|       |    // append
  696|    178|    std::string tx_extra_str = oss.str();
  697|    178|    size_t pos = tx_extra.size();
  698|    178|    tx_extra.resize(tx_extra.size() + tx_extra_str.size());
  699|    178|    memcpy(&tx_extra[pos], tx_extra_str.data(), tx_extra_str.size());
  700|    178|    return true;
  701|    178|  }
_ZN10cryptonote27add_extra_nonce_to_tx_extraERNSt3__16vectorIhNS0_9allocatorIhEEEERKNS0_12basic_stringIcNS0_11char_traitsIcEENS2_IcEEEE:
  704|    473|  {
  705|    473|    CHECK_AND_ASSERT_MES(extra_nonce.size() <= TX_EXTRA_NONCE_MAX_COUNT, false, "extra nonce could be 255 bytes max");
  ------------------
  |  |  183|    473|#define CHECK_AND_ASSERT_MES(expr, fail_ret_val, message)   do{if(!(expr)) {LOG_ERROR(message); return fail_ret_val;};}while(0)
  |  |  ------------------
  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (183:67): [True: 0, False: 473]
  |  |  |  Branch (183:126): [Folded - Ignored]
  |  |  ------------------
  ------------------
  706|    473|    size_t start_pos = tx_extra.size();
  707|    473|    tx_extra.resize(tx_extra.size() + 2 + extra_nonce.size());
  708|       |    //write tag
  709|    473|    tx_extra[start_pos] = TX_EXTRA_NONCE;
  ------------------
  |  |   39|    473|#define TX_EXTRA_NONCE                      0x02
  ------------------
  710|       |    //write len
  711|    473|    ++start_pos;
  712|    473|    tx_extra[start_pos] = static_cast<uint8_t>(extra_nonce.size());
  713|       |    //write data
  714|    473|    ++start_pos;
  715|    473|    memcpy(&tx_extra[start_pos], extra_nonce.data(), extra_nonce.size());
  716|    473|    return true;
  717|    473|  }
_ZN10cryptonote26remove_field_from_tx_extraERNSt3__16vectorIhNS0_9allocatorIhEEEERKSt9type_info:
  745|     92|  {
  746|     92|    if (tx_extra.empty())
  ------------------
  |  Branch (746:9): [True: 0, False: 92]
  ------------------
  747|      0|      return true;
  748|     92|    std::string extra_str(reinterpret_cast<const char*>(tx_extra.data()), tx_extra.size());
  749|     92|    binary_archive<false> ar{epee::strspan<std::uint8_t>(extra_str)};
  750|     92|    std::ostringstream oss;
  751|     92|    binary_archive<true> newar(oss);
  752|       |
  753|     92|    do
  754|  4.02k|    {
  755|  4.02k|      tx_extra_field field;
  756|  4.02k|      bool r = ::do_serialize(ar, field);
  757|  4.02k|      CHECK_AND_NO_ASSERT_MES_L1(r, false, "failed to deserialize extra field. extra = " << string_tools::buff_to_hex_nodelimer(std::string(reinterpret_cast<const char*>(tx_extra.data()), tx_extra.size())));
  ------------------
  |  |  195|  4.02k|#define CHECK_AND_NO_ASSERT_MES_L1(expr, fail_ret_val, message) CHECK_AND_NO_ASSERT_MES_L(expr, fail_ret_val, 1, message)
  |  |  ------------------
  |  |  |  |  187|  4.02k|#define CHECK_AND_NO_ASSERT_MES_L(expr, fail_ret_val, l, message)   do{if(!(expr)) {LOG_PRINT_L##l(message); /*LOCAL_ASSERT(expr);*/ return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (187:75): [True: 0, False: 4.02k]
  |  |  |  |  |  Branch (187:163): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  758|  4.02k|      if (field.type() != type)
  ------------------
  |  Branch (758:11): [True: 1.61k, False: 2.41k]
  ------------------
  759|  1.61k|        ::do_serialize(newar, field);
  760|  4.02k|    } while (!ar.eof());
  ------------------
  |  Branch (760:14): [True: 3.93k, False: 92]
  ------------------
  761|     92|    CHECK_AND_NO_ASSERT_MES_L1(::serialization::check_stream_state(ar), false, "failed to deserialize extra field. extra = " << string_tools::buff_to_hex_nodelimer(std::string(reinterpret_cast<const char*>(tx_extra.data()), tx_extra.size())));
  ------------------
  |  |  195|     92|#define CHECK_AND_NO_ASSERT_MES_L1(expr, fail_ret_val, message) CHECK_AND_NO_ASSERT_MES_L(expr, fail_ret_val, 1, message)
  |  |  ------------------
  |  |  |  |  187|     92|#define CHECK_AND_NO_ASSERT_MES_L(expr, fail_ret_val, l, message)   do{if(!(expr)) {LOG_PRINT_L##l(message); /*LOCAL_ASSERT(expr);*/ return fail_ret_val;};}while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (187:75): [True: 0, False: 92]
  |  |  |  |  |  Branch (187:163): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  762|     92|    tx_extra.clear();
  763|     92|    std::string s = oss.str();
  764|     92|    tx_extra.reserve(s.size());
  765|     92|    std::copy(s.begin(), s.end(), std::back_inserter(tx_extra));
  766|     92|    return true;
  767|     92|  }
_ZN10cryptonote42set_encrypted_payment_id_to_tx_extra_nonceERNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEERKN6crypto5hash8E:
  778|    473|  {
  779|    473|    extra_nonce.clear();
  780|    473|    extra_nonce.push_back(TX_EXTRA_NONCE_ENCRYPTED_PAYMENT_ID);
  ------------------
  |  |   45|    473|#define TX_EXTRA_NONCE_ENCRYPTED_PAYMENT_ID 0x01
  ------------------
  781|    473|    const uint8_t* payment_id_ptr = reinterpret_cast<const uint8_t*>(&payment_id);
  782|    473|    std::copy(payment_id_ptr, payment_id_ptr + sizeof(payment_id), std::back_inserter(extra_nonce));
  783|    473|  }
_ZN10cryptonote34get_payment_id_from_tx_extra_nonceERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEERN6crypto4hashE:
  786|     22|  {
  787|     22|    if(sizeof(crypto::hash) + 1 != extra_nonce.size())
  ------------------
  |  Branch (787:8): [True: 20, False: 2]
  ------------------
  788|     20|      return false;
  789|      2|    if(TX_EXTRA_NONCE_PAYMENT_ID != extra_nonce[0])
  ------------------
  |  |   44|      2|#define TX_EXTRA_NONCE_PAYMENT_ID           0x00
  ------------------
  |  Branch (789:8): [True: 1, False: 1]
  ------------------
  790|      1|      return false;
  791|      1|    payment_id = *reinterpret_cast<const crypto::hash*>(extra_nonce.data() + 1);
  792|      1|    return true;
  793|      2|  }
_ZN10cryptonote44get_encrypted_payment_id_from_tx_extra_nonceERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEERN6crypto5hash8E:
  796|    140|  {
  797|    140|    if(sizeof(crypto::hash8) + 1 != extra_nonce.size())
  ------------------
  |  Branch (797:8): [True: 19, False: 121]
  ------------------
  798|     19|      return false;
  799|    121|    if (TX_EXTRA_NONCE_ENCRYPTED_PAYMENT_ID != extra_nonce[0])
  ------------------
  |  |   45|    121|#define TX_EXTRA_NONCE_ENCRYPTED_PAYMENT_ID 0x01
  ------------------
  |  Branch (799:9): [True: 3, False: 118]
  ------------------
  800|      3|      return false;
  801|    118|    payment_id = *reinterpret_cast<const crypto::hash8*>(extra_nonce.data() + 1);
  802|    118|    return true;
  803|    121|  }
_ZN10cryptonote21get_outs_money_amountERKNS_11transactionE:
  885|      1|  {
  886|      1|    uint64_t outputs_amount = 0;
  887|      1|    for(const auto& o: tx.vout)
  ------------------
  |  Branch (887:22): [True: 1, False: 1]
  ------------------
  888|      1|      outputs_amount += o.amount;
  889|      1|    return outputs_amount;
  890|      1|  }
_ZN10cryptonote21get_output_public_keyERKNS_6tx_outERN6crypto10public_keyE:
  893|  23.9k|  {
  894|       |    // before HF_VERSION_VIEW_TAGS, outputs with public keys are of type txout_to_key
  895|       |    // after HF_VERSION_VIEW_TAGS, outputs with public keys are of type txout_to_tagged_key
  896|  23.9k|    if (out.target.type() == typeid(txout_to_key))
  ------------------
  |  Branch (896:9): [True: 7.71k, False: 16.2k]
  ------------------
  897|  7.71k|      output_public_key = boost::get< txout_to_key >(out.target).key;
  898|  16.2k|    else if (out.target.type() == typeid(txout_to_tagged_key))
  ------------------
  |  Branch (898:14): [True: 1.09k, False: 15.1k]
  ------------------
  899|  1.09k|      output_public_key = boost::get< txout_to_tagged_key >(out.target).key;
  900|  15.1k|    else
  901|  15.1k|    {
  902|  15.1k|      LOG_ERROR("Unexpected output target type found: " << out.target.type().name());
  ------------------
  |  |  100|  15.1k|#define LOG_ERROR(x) MERROR(x)
  |  |  ------------------
  |  |  |  |   75|  15.1k|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   53|  15.1k|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|  15.1k|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|  15.1k|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|  15.1k|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 15.1k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|  15.1k|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  903|  15.1k|      return false;
  904|  15.1k|    }
  905|       |
  906|  8.80k|    return true;
  907|  23.9k|  }
_ZN10cryptonote19get_output_view_tagERKNS_6tx_outE:
  910|  8.59k|  {
  911|  8.59k|    return out.target.type() == typeid(txout_to_tagged_key)
  ------------------
  |  Branch (911:12): [True: 1.08k, False: 7.50k]
  ------------------
  912|  8.59k|      ? boost::optional<crypto::view_tag>(boost::get< txout_to_tagged_key >(out.target).view_tag)
  913|  8.59k|      : boost::optional<crypto::view_tag>();
  914|  8.59k|  }
_ZN10cryptonote17out_can_be_to_accERKN5boost8optionalIN6crypto8view_tagEEERKNS2_14key_derivationEmPN2hw6deviceE:
  976|  11.0k|  {
  977|       |    // If there is no view tag to check, the output can possibly belong to the account.
  978|       |    // Will need to derive the output pub key to be certain whether or not the output belongs to the account.
  979|  11.0k|    if (!view_tag_opt)
  ------------------
  |  Branch (979:9): [True: 9.94k, False: 1.08k]
  ------------------
  980|  9.94k|      return true;
  981|       |
  982|  1.08k|    crypto::view_tag view_tag = *view_tag_opt;
  983|       |
  984|       |    // If the output's view tag does *not* match the derived view tag, the output should not belong to the account.
  985|       |    // Therefore can fail out early to avoid expensive crypto ops needlessly deriving output public key to
  986|       |    // determine if output belongs to the account.
  987|  1.08k|    crypto::view_tag derived_view_tag;
  988|  1.08k|    if (hwdev != nullptr)
  ------------------
  |  Branch (988:9): [True: 1.08k, False: 0]
  ------------------
  989|  1.08k|    {
  990|  1.08k|      bool r = hwdev->derive_view_tag(derivation, output_index, derived_view_tag);
  991|  1.08k|      CHECK_AND_ASSERT_MES(r, false, "Failed to derive view tag");
  ------------------
  |  |  183|  1.08k|#define CHECK_AND_ASSERT_MES(expr, fail_ret_val, message)   do{if(!(expr)) {LOG_ERROR(message); return fail_ret_val;};}while(0)
  |  |  ------------------
  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (183:67): [True: 0, False: 1.08k]
  |  |  |  Branch (183:126): [Folded - Ignored]
  |  |  ------------------
  ------------------
  992|  1.08k|    }
  993|      0|    else
  994|      0|    {
  995|      0|      crypto::derive_view_tag(derivation, output_index, derived_view_tag);
  996|      0|    }
  997|  1.08k|    return view_tag == derived_view_tag;
  998|  1.08k|  }
_ZN10cryptonote21is_out_to_acc_precompERKNSt3__113unordered_mapIN6crypto10public_keyENS_16subaddress_indexENS0_4hashIS3_EENS0_8equal_toIS3_EENS0_9allocatorINS0_4pairIKS3_S4_EEEEEERSB_RKNS2_14key_derivationERKNS0_6vectorISI_NS9_ISI_EEEEmRN2hw6deviceERKN5boost8optionalINS2_8view_tagEEE:
 1031|  10.9k|  {
 1032|       |    // try the shared tx pubkey
 1033|  10.9k|    crypto::public_key subaddress_spendkey;
 1034|  10.9k|    if (out_can_be_to_acc(view_tag_opt, derivation, output_index, &hwdev))
  ------------------
  |  Branch (1034:9): [True: 9.90k, False: 1.05k]
  ------------------
 1035|  9.90k|    {
 1036|  9.90k|      CHECK_AND_ASSERT_MES(hwdev.derive_subaddress_public_key(out_key, derivation, output_index, subaddress_spendkey), boost::none, "Failed to derive subaddress public key");
  ------------------
  |  |  183|  9.90k|#define CHECK_AND_ASSERT_MES(expr, fail_ret_val, message)   do{if(!(expr)) {LOG_ERROR(message); return fail_ret_val;};}while(0)
  |  |  ------------------
  |  |  |  |  100|  3.64k|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|  3.64k|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|  3.64k|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|  3.64k|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|  3.64k|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|  3.64k|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 3.64k]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|  3.64k|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (183:67): [True: 3.64k, False: 6.25k]
  |  |  |  Branch (183:126): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1037|  6.25k|      auto found = subaddresses.find(subaddress_spendkey);
 1038|  6.25k|      if (found != subaddresses.end())
  ------------------
  |  Branch (1038:11): [True: 1, False: 6.25k]
  ------------------
 1039|      1|        return subaddress_receive_info{ found->second, derivation };
 1040|  6.25k|    }
 1041|       |
 1042|       |    // try additional tx pubkeys if available
 1043|  7.31k|    if (!additional_derivations.empty())
  ------------------
  |  Branch (1043:9): [True: 229, False: 7.08k]
  ------------------
 1044|    229|    {
 1045|    229|      CHECK_AND_ASSERT_MES(output_index < additional_derivations.size(), boost::none, "wrong number of additional derivations");
  ------------------
  |  |  183|    229|#define CHECK_AND_ASSERT_MES(expr, fail_ret_val, message)   do{if(!(expr)) {LOG_ERROR(message); return fail_ret_val;};}while(0)
  |  |  ------------------
  |  |  |  |  100|    162|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|    162|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|    162|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|    162|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|    162|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|    162|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 162]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|    162|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (183:67): [True: 162, False: 67]
  |  |  |  Branch (183:126): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1046|     67|      if (out_can_be_to_acc(view_tag_opt, additional_derivations[output_index], output_index, &hwdev))
  ------------------
  |  Branch (1046:11): [True: 67, False: 0]
  ------------------
 1047|     67|      {
 1048|     67|        CHECK_AND_ASSERT_MES(hwdev.derive_subaddress_public_key(out_key, additional_derivations[output_index], output_index, subaddress_spendkey), boost::none, "Failed to derive subaddress public key");
  ------------------
  |  |  183|     67|#define CHECK_AND_ASSERT_MES(expr, fail_ret_val, message)   do{if(!(expr)) {LOG_ERROR(message); return fail_ret_val;};}while(0)
  |  |  ------------------
  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (183:67): [True: 0, False: 67]
  |  |  |  Branch (183:126): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1049|     67|        auto found = subaddresses.find(subaddress_spendkey);
 1050|     67|        if (found != subaddresses.end())
  ------------------
  |  Branch (1050:13): [True: 0, False: 67]
  ------------------
 1051|      0|          return subaddress_receive_info{ found->second, additional_derivations[output_index] };
 1052|     67|      }
 1053|     67|    }
 1054|  7.15k|    return boost::none;
 1055|  7.31k|  }
_ZN10cryptonote13get_blob_hashERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEERN6crypto4hashE:
 1091|      2|  {
 1092|      2|    cn_fast_hash(blob.data(), blob.size(), res);
 1093|      2|  }
_ZN10cryptonote26calculate_transaction_hashERKNS_11transactionERN6crypto4hashEPm:
 1336|      1|  {
 1337|      1|    CHECK_AND_ASSERT_MES(!t.pruned, false, "Cannot calculate the hash of a pruned transaction");
  ------------------
  |  |  183|      1|#define CHECK_AND_ASSERT_MES(expr, fail_ret_val, message)   do{if(!(expr)) {LOG_ERROR(message); return fail_ret_val;};}while(0)
  |  |  ------------------
  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (183:67): [True: 0, False: 1]
  |  |  |  Branch (183:126): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1338|       |
 1339|       |    // v1 transactions hash the entire blob
 1340|      1|    if (t.version == 1)
  ------------------
  |  Branch (1340:9): [True: 1, False: 0]
  ------------------
 1341|      1|    {
 1342|      1|      size_t ignored_blob_size, &blob_size_ref = blob_size ? *blob_size : ignored_blob_size;
  ------------------
  |  Branch (1342:50): [True: 1, False: 0]
  ------------------
 1343|      1|      return get_object_hash(t, res, blob_size_ref);
 1344|      1|    }
 1345|       |
 1346|       |    // v2 transactions hash different parts together, than hash the set of those hashes
 1347|      0|    crypto::hash hashes[3];
 1348|       |
 1349|       |    // prefix
 1350|      0|    get_transaction_prefix_hash(t, hashes[0]);
 1351|       |
 1352|      0|    const blobdata blob = tx_to_blob(t);
 1353|      0|    const unsigned int unprunable_size = t.unprunable_size;
 1354|      0|    const unsigned int prefix_size = t.prefix_size;
 1355|       |
 1356|       |    // base rct
 1357|      0|    CHECK_AND_ASSERT_MES(prefix_size <= unprunable_size && unprunable_size <= blob.size(), false, "Inconsistent transaction prefix, unprunable and blob sizes");
  ------------------
  |  |  183|      0|#define CHECK_AND_ASSERT_MES(expr, fail_ret_val, message)   do{if(!(expr)) {LOG_ERROR(message); return fail_ret_val;};}while(0)
  |  |  ------------------
  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (183:69): [True: 0, False: 0]
  |  |  |  Branch (183:69): [True: 0, False: 0]
  |  |  |  Branch (183:126): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1358|      0|    cryptonote::get_blob_hash(blobdata_ref(blob.data() + prefix_size, unprunable_size - prefix_size), hashes[1]);
 1359|       |
 1360|       |    // prunable rct
 1361|      0|    if (t.rct_signatures.type == rct::RCTTypeNull)
  ------------------
  |  Branch (1361:9): [True: 0, False: 0]
  ------------------
 1362|      0|    {
 1363|      0|      hashes[2] = crypto::null_hash;
 1364|      0|    }
 1365|      0|    else
 1366|      0|    {
 1367|      0|      cryptonote::blobdata_ref blobref(blob);
 1368|      0|      CHECK_AND_ASSERT_MES(calculate_transaction_prunable_hash(t, &blobref, hashes[2]), false, "Failed to get tx prunable hash");
  ------------------
  |  |  183|      0|#define CHECK_AND_ASSERT_MES(expr, fail_ret_val, message)   do{if(!(expr)) {LOG_ERROR(message); return fail_ret_val;};}while(0)
  |  |  ------------------
  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (183:67): [True: 0, False: 0]
  |  |  |  Branch (183:126): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1369|      0|    }
 1370|       |
 1371|       |    // the tx hash is the hash of the 3 hashes
 1372|      0|    res = cn_fast_hash(hashes, sizeof(hashes));
 1373|       |
 1374|       |    // we still need the size
 1375|      0|    if (blob_size)
  ------------------
  |  Branch (1375:9): [True: 0, False: 0]
  ------------------
 1376|      0|    {
 1377|      0|      if (!t.is_blob_size_valid())
  ------------------
  |  Branch (1377:11): [True: 0, False: 0]
  ------------------
 1378|      0|      {
 1379|      0|        t.set_blob_size(blob.size());
 1380|      0|      }
 1381|      0|      *blob_size = t.blob_size;
 1382|      0|    }
 1383|       |
 1384|      0|    return true;
 1385|      0|  }
_ZN10cryptonote20get_transaction_hashERKNS_11transactionERN6crypto4hashEPm:
 1388|      2|  {
 1389|      2|    if (t.is_hash_valid())
  ------------------
  |  Branch (1389:9): [True: 1, False: 1]
  ------------------
 1390|      1|    {
 1391|       |#ifdef ENABLE_HASH_CASH_INTEGRITY_CHECK
 1392|       |      CHECK_AND_ASSERT_THROW_MES(!calculate_transaction_hash(t, res, blob_size) || t.hash == res, "tx hash cash integrity failure");
 1393|       |#endif
 1394|      1|      res = t.hash;
 1395|      1|      if (blob_size)
  ------------------
  |  Branch (1395:11): [True: 1, False: 0]
  ------------------
 1396|      1|      {
 1397|      1|        if (!t.is_blob_size_valid())
  ------------------
  |  Branch (1397:13): [True: 0, False: 1]
  ------------------
 1398|      0|        {
 1399|      0|          t.set_blob_size(get_object_blobsize(t));
 1400|      0|        }
 1401|      1|        *blob_size = t.blob_size;
 1402|      1|      }
 1403|      1|      ++tx_hashes_cached_count;
 1404|      1|      return true;
 1405|      1|    }
 1406|      1|    ++tx_hashes_calculated_count;
 1407|      1|    bool ret = calculate_transaction_hash(t, res, blob_size);
 1408|      1|    if (!ret)
  ------------------
  |  Branch (1408:9): [True: 0, False: 1]
  ------------------
 1409|      0|      return false;
 1410|      1|    t.set_hash(res);
 1411|      1|    if (blob_size)
  ------------------
  |  Branch (1411:9): [True: 1, False: 0]
  ------------------
 1412|      1|    {
 1413|      1|      t.set_blob_size(*blob_size);
 1414|      1|    }
 1415|      1|    return true;
 1416|      1|  }
_ZN10cryptonote20get_transaction_hashERKNS_11transactionERN6crypto4hashERm:
 1419|      2|  {
 1420|      2|    return get_transaction_hash(t, res, &blob_size);
 1421|      2|  }
_ZN10cryptonote22get_block_hashing_blobERKNS_5blockE:
 1424|      2|  {
 1425|      2|    blobdata blob = t_serializable_object_to_blob(static_cast<block_header>(b));
 1426|      2|    crypto::hash tree_root_hash = get_tx_tree_hash(b);
 1427|      2|    blob.append(reinterpret_cast<const char*>(&tree_root_hash), sizeof(tree_root_hash));
 1428|      2|    blob.append(tools::get_varint_data(b.tx_hashes.size()+1));
 1429|      2|    return blob;
 1430|      2|  }
_ZN10cryptonote20calculate_block_hashERKNS_5blockERN6crypto4hashEPKN5boost16basic_string_refIcNSt3__111char_traitsIcEEEE:
 1433|      1|  {
 1434|      1|    blobdata bd;
 1435|      1|    blobdata_ref bdref;
 1436|      1|    if (!blob)
  ------------------
  |  Branch (1436:9): [True: 1, False: 0]
  ------------------
 1437|      1|    {
 1438|      1|      bd = block_to_blob(b);
 1439|      1|      bdref = bd;
 1440|      1|      blob = &bdref;
 1441|      1|    }
 1442|       |
 1443|      1|    bool hash_result = get_object_hash(get_block_hashing_blob(b), res);
 1444|      1|    if (!hash_result)
  ------------------
  |  Branch (1444:9): [True: 0, False: 1]
  ------------------
 1445|      0|      return false;
 1446|       |
 1447|      1|    if (b.miner_tx.vin.size() == 1 && b.miner_tx.vin[0].type() == typeid(cryptonote::txin_gen))
  ------------------
  |  Branch (1447:9): [True: 1, False: 0]
  |  Branch (1447:39): [True: 1, False: 0]
  ------------------
 1448|      1|    {
 1449|      1|      const cryptonote::txin_gen &txin_gen = boost::get<cryptonote::txin_gen>(b.miner_tx.vin[0]);
 1450|      1|      if (txin_gen.height != 202612)
  ------------------
  |  Branch (1450:11): [True: 1, False: 0]
  ------------------
 1451|      1|        return true;
 1452|      1|    }
 1453|       |
 1454|       |    // EXCEPTION FOR BLOCK 202612
 1455|      0|    const std::string correct_blob_hash_202612 = "3a8a2b3a29b50fc86ff73dd087ea43c6f0d6b8f936c849194d5c84c737903966";
 1456|      0|    const std::string existing_block_id_202612 = "bbd604d2ba11ba27935e006ed39c9bfdd99b76bf4a50654bc1e1e61217962698";
 1457|      0|    crypto::hash block_blob_hash = get_blob_hash(*blob);
 1458|       |
 1459|      0|    if (string_tools::pod_to_hex(block_blob_hash) == correct_blob_hash_202612)
  ------------------
  |  Branch (1459:9): [True: 0, False: 0]
  ------------------
 1460|      0|    {
 1461|      0|      string_tools::hex_to_pod(existing_block_id_202612, res);
 1462|      0|      return true;
 1463|      0|    }
 1464|       |
 1465|      0|    {
 1466|       |      // make sure that we aren't looking at a block with the 202612 block id but not the correct blobdata
 1467|      0|      if (string_tools::pod_to_hex(res) == existing_block_id_202612)
  ------------------
  |  Branch (1467:11): [True: 0, False: 0]
  ------------------
 1468|      0|      {
 1469|      0|        LOG_ERROR("Block with block id for 202612 but incorrect block blob hash found!");
  ------------------
  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  ------------------
  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1470|      0|        res = null_hash;
 1471|      0|        return false;
 1472|      0|      }
 1473|      0|    }
 1474|      0|    return hash_result;
 1475|      0|  }
_ZN10cryptonote14get_block_hashERKNS_5blockERN6crypto4hashE:
 1478|      1|  {
 1479|      1|    if (b.is_hash_valid())
  ------------------
  |  Branch (1479:9): [True: 0, False: 1]
  ------------------
 1480|      0|    {
 1481|       |#ifdef ENABLE_HASH_CASH_INTEGRITY_CHECK
 1482|       |      CHECK_AND_ASSERT_THROW_MES(!calculate_block_hash(b, res) || b.hash == res, "block hash cash integrity failure");
 1483|       |#endif
 1484|      0|      res = b.hash;
 1485|      0|      ++block_hashes_cached_count;
 1486|      0|      return true;
 1487|      0|    }
 1488|      1|    ++block_hashes_calculated_count;
 1489|      1|    bool ret = calculate_block_hash(b, res);
 1490|      1|    if (!ret)
  ------------------
  |  Branch (1490:9): [True: 0, False: 1]
  ------------------
 1491|      0|      return false;
 1492|      1|    b.set_hash(res);
 1493|      1|    return true;
 1494|      1|  }
_ZN10cryptonote14get_block_hashERKNS_5blockE:
 1497|      1|  {
 1498|      1|    crypto::hash p = null_hash;
 1499|      1|    get_block_hash(b, p);
 1500|      1|    return p;
 1501|      1|  }
_ZN10cryptonote13block_to_blobERKNS_5blockE:
 1550|      1|  {
 1551|      1|    return t_serializable_object_to_blob(b);
 1552|      1|  }
_ZN10cryptonote16get_tx_tree_hashERKNSt3__16vectorIN6crypto4hashENS0_9allocatorIS3_EEEERS3_:
 1570|      2|  {
 1571|      2|    tree_hash(tx_hashes.data(), tx_hashes.size(), h);
 1572|      2|  }
_ZN10cryptonote16get_tx_tree_hashERKNSt3__16vectorIN6crypto4hashENS0_9allocatorIS3_EEEE:
 1575|      2|  {
 1576|      2|    crypto::hash h = null_hash;
 1577|      2|    get_tx_tree_hash(tx_hashes, h);
 1578|      2|    return h;
 1579|      2|  }
_ZN10cryptonote16get_tx_tree_hashERKNS_5blockE:
 1582|      2|  {
 1583|      2|    std::vector<crypto::hash> txs_ids;
 1584|      2|    txs_ids.reserve(1 + b.tx_hashes.size());
 1585|      2|    crypto::hash h = null_hash;
 1586|      2|    size_t bl_sz = 0;
 1587|      2|    CHECK_AND_ASSERT_THROW_MES(get_transaction_hash(b.miner_tx, h, bl_sz), "Failed to calculate transaction hash");
  ------------------
  |  |  175|      2|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0)
  |  |  ------------------
  |  |  |  |  174|      0|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());}
  |  |  |  |  ------------------
  |  |  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (175:58): [True: 0, False: 2]
  |  |  |  Branch (175:105): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1588|      2|    txs_ids.push_back(h);
 1589|      2|    for(auto& th: b.tx_hashes)
  ------------------
  |  Branch (1589:17): [True: 0, False: 2]
  ------------------
 1590|      0|      txs_ids.push_back(th);
 1591|      2|    return get_tx_tree_hash(txs_ids);
 1592|      2|  }
cryptonote_format_utils.cpp:_ZN10cryptonoteadERN6crypto8ec_pointE:
   63|  1.03k|  static inline unsigned char *operator &(ec_point &point) {
   64|  1.03k|    return &reinterpret_cast<unsigned char &>(point);
   65|  1.03k|  }

_ZN10cryptonote27find_tx_extra_field_by_typeINS_14tx_extra_nonceEEEbRKNSt3__16vectorIN5boost7variantINS_16tx_extra_paddingEJNS_16tx_extra_pub_keyES1_NS_25tx_extra_merge_mining_tagENS_28tx_extra_additional_pub_keysENS_29tx_extra_mysterious_minergateEEEENS2_9allocatorISB_EEEERT_m:
   65|  1.34k|  {
   66|  1.34k|    auto it = std::find_if(tx_extra_fields.begin(), tx_extra_fields.end(), [&index](const tx_extra_field& f) { return typeid(T) == f.type() && !index--; });
   67|  1.34k|    if(tx_extra_fields.end() == it)
  ------------------
  |  Branch (67:8): [True: 1.20k, False: 140]
  ------------------
   68|  1.20k|      return false;
   69|       |
   70|    140|    field = boost::get<T>(*it);
   71|    140|    return true;
   72|  1.34k|  }
_ZZN10cryptonote27find_tx_extra_field_by_typeINS_14tx_extra_nonceEEEbRKNSt3__16vectorIN5boost7variantINS_16tx_extra_paddingEJNS_16tx_extra_pub_keyES1_NS_25tx_extra_merge_mining_tagENS_28tx_extra_additional_pub_keysENS_29tx_extra_mysterious_minergateEEEENS2_9allocatorISB_EEEERT_mENKUlRKSB_E_clESK_:
   66|    188|    auto it = std::find_if(tx_extra_fields.begin(), tx_extra_fields.end(), [&index](const tx_extra_field& f) { return typeid(T) == f.type() && !index--; });
  ------------------
  |  Branch (66:119): [True: 140, False: 48]
  |  Branch (66:144): [True: 140, False: 0]
  ------------------
_ZN10cryptonote27find_tx_extra_field_by_typeINS_16tx_extra_pub_keyEEEbRKNSt3__16vectorIN5boost7variantINS_16tx_extra_paddingEJS1_NS_14tx_extra_nonceENS_25tx_extra_merge_mining_tagENS_28tx_extra_additional_pub_keysENS_29tx_extra_mysterious_minergateEEEENS2_9allocatorISB_EEEERT_m:
   65|  2.34k|  {
   66|  2.34k|    auto it = std::find_if(tx_extra_fields.begin(), tx_extra_fields.end(), [&index](const tx_extra_field& f) { return typeid(T) == f.type() && !index--; });
   67|  2.34k|    if(tx_extra_fields.end() == it)
  ------------------
  |  Branch (67:8): [True: 607, False: 1.73k]
  ------------------
   68|    607|      return false;
   69|       |
   70|  1.73k|    field = boost::get<T>(*it);
   71|  1.73k|    return true;
   72|  2.34k|  }
_ZZN10cryptonote27find_tx_extra_field_by_typeINS_16tx_extra_pub_keyEEEbRKNSt3__16vectorIN5boost7variantINS_16tx_extra_paddingEJS1_NS_14tx_extra_nonceENS_25tx_extra_merge_mining_tagENS_28tx_extra_additional_pub_keysENS_29tx_extra_mysterious_minergateEEEENS2_9allocatorISB_EEEERT_mENKUlRKSB_E_clESK_:
   66|  42.5k|    auto it = std::find_if(tx_extra_fields.begin(), tx_extra_fields.end(), [&index](const tx_extra_field& f) { return typeid(T) == f.type() && !index--; });
  ------------------
  |  Branch (66:119): [True: 18.7k, False: 23.7k]
  |  Branch (66:144): [True: 1.73k, False: 17.0k]
  ------------------
_ZN10cryptonote27find_tx_extra_field_by_typeINS_28tx_extra_additional_pub_keysEEEbRKNSt3__16vectorIN5boost7variantINS_16tx_extra_paddingEJNS_16tx_extra_pub_keyENS_14tx_extra_nonceENS_25tx_extra_merge_mining_tagES1_NS_29tx_extra_mysterious_minergateEEEENS2_9allocatorISB_EEEERT_m:
   65|    427|  {
   66|    427|    auto it = std::find_if(tx_extra_fields.begin(), tx_extra_fields.end(), [&index](const tx_extra_field& f) { return typeid(T) == f.type() && !index--; });
   67|    427|    if(tx_extra_fields.end() == it)
  ------------------
  |  Branch (67:8): [True: 398, False: 29]
  ------------------
   68|    398|      return false;
   69|       |
   70|     29|    field = boost::get<T>(*it);
   71|     29|    return true;
   72|    427|  }
_ZZN10cryptonote27find_tx_extra_field_by_typeINS_28tx_extra_additional_pub_keysEEEbRKNSt3__16vectorIN5boost7variantINS_16tx_extra_paddingEJNS_16tx_extra_pub_keyENS_14tx_extra_nonceENS_25tx_extra_merge_mining_tagES1_NS_29tx_extra_mysterious_minergateEEEENS2_9allocatorISB_EEEERT_mENKUlRKSB_E_clESK_:
   66|  2.19k|    auto it = std::find_if(tx_extra_fields.begin(), tx_extra_fields.end(), [&index](const tx_extra_field& f) { return typeid(T) == f.type() && !index--; });
  ------------------
  |  Branch (66:119): [True: 29, False: 2.16k]
  |  Branch (66:144): [True: 29, False: 0]
  ------------------
_ZN10cryptonote29t_serializable_object_to_blobINS_11transactionEEENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKT_:
  175|      1|  {
  176|      1|    blobdata b;
  177|      1|    t_serializable_object_to_blob(to, b);
  178|      1|    return b;
  179|      1|  }
_ZN10cryptonote29t_serializable_object_to_blobINS_11transactionEEEbRKT_RNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE:
  165|      1|  {
  166|      1|    std::stringstream ss;
  167|      1|    binary_archive<true> ba(ss);
  168|      1|    bool r = ::serialization::serialize(ba, const_cast<t_object&>(to));
  169|      1|    b_blob = ss.str();
  170|      1|    return r;
  171|      1|  }
_ZN10cryptonote15get_object_hashINS_11transactionEEEbRKT_RN6crypto4hashERm:
  197|      1|  {
  198|      1|    blobdata bl = t_serializable_object_to_blob(o);
  199|      1|    blob_size = bl.size();
  200|      1|    get_blob_hash(bl, res);
  201|      1|    return true;
  202|      1|  }
_ZN10cryptonote29t_serializable_object_to_blobINS_12block_headerEEENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKT_:
  175|      2|  {
  176|      2|    blobdata b;
  177|      2|    t_serializable_object_to_blob(to, b);
  178|      2|    return b;
  179|      2|  }
_ZN10cryptonote29t_serializable_object_to_blobINS_12block_headerEEEbRKT_RNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE:
  165|      2|  {
  166|      2|    std::stringstream ss;
  167|      2|    binary_archive<true> ba(ss);
  168|      2|    bool r = ::serialization::serialize(ba, const_cast<t_object&>(to));
  169|      2|    b_blob = ss.str();
  170|      2|    return r;
  171|      2|  }
_ZN10cryptonote15get_object_hashINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEbRKT_RN6crypto4hashE:
  183|      1|  {
  184|      1|    get_blob_hash(t_serializable_object_to_blob(o), res);
  185|      1|    return true;
  186|      1|  }
_ZN10cryptonote29t_serializable_object_to_blobINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEES7_RKT_:
  175|      1|  {
  176|      1|    blobdata b;
  177|      1|    t_serializable_object_to_blob(to, b);
  178|      1|    return b;
  179|      1|  }
_ZN10cryptonote29t_serializable_object_to_blobINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEbRKT_RS7_:
  165|      1|  {
  166|      1|    std::stringstream ss;
  167|      1|    binary_archive<true> ba(ss);
  168|      1|    bool r = ::serialization::serialize(ba, const_cast<t_object&>(to));
  169|      1|    b_blob = ss.str();
  170|      1|    return r;
  171|      1|  }
_ZN10cryptonote29t_serializable_object_to_blobINS_5blockEEENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKT_:
  175|      1|  {
  176|      1|    blobdata b;
  177|      1|    t_serializable_object_to_blob(to, b);
  178|      1|    return b;
  179|      1|  }
_ZN10cryptonote29t_serializable_object_to_blobINS_5blockEEEbRKT_RNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE:
  165|      1|  {
  166|      1|    std::stringstream ss;
  167|      1|    binary_archive<true> ba(ss);
  168|      1|    bool r = ::serialization::serialize(ba, const_cast<t_object&>(to));
  169|      1|    b_blob = ss.str();
  170|      1|    return r;
  171|      1|  }

_ZN10cryptonote27get_transaction_prefix_hashERKNS_18transaction_prefixERN6crypto4hashE:
   36|     22|  {
   37|     22|    std::ostringstream s;
   38|     22|    binary_archive<true> a(s);
   39|     22|    ::serialization::serialize(a, const_cast<transaction_prefix&>(tx));
   40|     22|    crypto::cn_fast_hash(s.str().data(), s.str().size(), h);
   41|     22|  }
_ZN10cryptonote27get_transaction_prefix_hashERKNS_18transaction_prefixE:
   44|     22|  {
   45|     22|    crypto::hash h = crypto::null_hash;
   46|     22|    get_transaction_prefix_hash(tx, h);
   47|     22|    return h;
   48|     22|  }

_ZN10cryptonote13check_hash_64ERKN6crypto4hashEm:
  105|      1|  bool check_hash_64(const crypto::hash &hash, uint64_t difficulty) {
  106|      1|    uint64_t low, high, top, cur;
  107|       |    // First check the highest word, this will most likely fail for a random hash.
  108|      1|    mul(swap64le(((const uint64_t *) &hash)[3]), difficulty, top, high);
  ------------------
  |  |  287|      1|#define swap64le ident64
  ------------------
  109|      1|    if (high != 0) {
  ------------------
  |  Branch (109:9): [True: 0, False: 1]
  ------------------
  110|      0|      return false;
  111|      0|    }
  112|      1|    mul(swap64le(((const uint64_t *) &hash)[0]), difficulty, low, cur);
  ------------------
  |  |  287|      1|#define swap64le ident64
  ------------------
  113|      1|    mul(swap64le(((const uint64_t *) &hash)[1]), difficulty, low, high);
  ------------------
  |  |  287|      1|#define swap64le ident64
  ------------------
  114|      1|    bool carry = cadd(cur, low);
  115|      1|    cur = high;
  116|      1|    mul(swap64le(((const uint64_t *) &hash)[2]), difficulty, low, high);
  ------------------
  |  |  287|      1|#define swap64le ident64
  ------------------
  117|      1|    carry = cadc(cur, low, carry);
  118|      1|    carry = cadc(high, top, carry);
  119|      1|    return !carry;
  120|      1|  }
_ZN10cryptonote10check_hashERKN6crypto4hashEN5boost14multiprecision6numberINS5_8backends15cpp_int_backendILm128ELm128ELNS5_16cpp_integer_typeE0ELNS5_18cpp_int_check_typeE0EvEELNS5_26expression_template_optionE0EEE:
  196|      1|  bool check_hash(const crypto::hash &hash, difficulty_type difficulty) {
  197|      1|    if (difficulty <= max64bit) // if can convert to small difficulty - do it
  ------------------
  |  Branch (197:9): [True: 1, False: 0]
  ------------------
  198|      1|      return check_hash_64(hash, difficulty.convert_to<std::uint64_t>());
  199|      0|    else
  200|      0|      return check_hash_128(hash, difficulty);
  201|      1|  }
difficulty.cpp:_ZN10cryptonoteL3mulEmmRmS0_:
   52|      4|  static inline void mul(uint64_t a, uint64_t b, uint64_t &low, uint64_t &high) {
   53|      4|    low = mul128(a, b, &high);
   54|      4|  }
difficulty.cpp:_ZN10cryptonoteL4caddEmm:
   97|      1|  static inline bool cadd(uint64_t a, uint64_t b) {
   98|      1|    return a + b < a;
   99|      1|  }
difficulty.cpp:_ZN10cryptonoteL4cadcEmmb:
  101|      2|  static inline bool cadc(uint64_t a, uint64_t b, bool c) {
  102|      2|    return a + b < a || (c && a + b == (uint64_t) -1);
  ------------------
  |  Branch (102:12): [True: 0, False: 2]
  |  Branch (102:26): [True: 0, False: 2]
  |  Branch (102:31): [True: 0, False: 0]
  ------------------
  103|      2|  }

_ZN10cryptonote5miner26find_nonce_for_given_blockERKNSt3__18functionIFbRKNS_5blockEmPKN6crypto4hashEjRS7_EEERS3_RKN5boost14multiprecision6numberINSH_8backends15cpp_int_backendILm128ELm128ELNSH_16cpp_integer_typeE0ELNSH_18cpp_int_check_typeE0EvEELNSH_26expression_template_optionE0EEEmS9_:
  478|      1|  {
  479|      1|    for(; bl.nonce != std::numeric_limits<uint32_t>::max(); bl.nonce++)
  ------------------
  |  Branch (479:11): [True: 1, False: 0]
  ------------------
  480|      1|    {
  481|      1|      crypto::hash h;
  482|      1|      gbh(bl, height, seed_hash, diffic <= 100 ? 0 : tools::get_max_concurrency(), h);
  ------------------
  |  Branch (482:34): [True: 1, False: 0]
  ------------------
  483|       |
  484|      1|      if(check_hash(h, diffic))
  ------------------
  |  Branch (484:10): [True: 1, False: 0]
  ------------------
  485|      1|      {
  486|      1|        bl.invalidate_hashes();
  487|      1|        return true;
  488|      1|      }
  489|      1|    }
  490|      0|    bl.invalidate_hashes();
  491|      0|    return false;
  492|      1|  }

_ZN10cryptonote16subaddress_index19do_serialize_objectILb0E14binary_archiveEEbRT0_IXT_EE:
   46|  10.6k|    BEGIN_SERIALIZE_OBJECT()
  ------------------
  |  |  184|  10.6k|  bool do_serialize_object(Archive<W> &ar){
  ------------------
   47|  10.6k|      FIELD(major)
  ------------------
  |  |  226|  10.6k|  do {							\
  |  |  227|  10.6k|    ar.tag(#f);						\
  |  |  228|  10.6k|    bool r = do_serialize(ar, f);			\
  |  |  229|  10.6k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 10.6k]
  |  |  |  Branch (229:15): [True: 9, False: 10.6k]
  |  |  ------------------
  |  |  230|  10.6k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
   48|  10.6k|      FIELD(minor)
  ------------------
  |  |  226|  10.6k|  do {							\
  |  |  227|  10.6k|    ar.tag(#f);						\
  |  |  228|  10.6k|    bool r = do_serialize(ar, f);			\
  |  |  229|  10.6k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 10.6k]
  |  |  |  Branch (229:15): [True: 16, False: 10.6k]
  |  |  ------------------
  |  |  230|  10.6k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
   49|  10.6k|    END_SERIALIZE()
  ------------------
  |  |  207|  10.6k|  return ar.good();				\
  |  |  208|  10.6k|  }
  ------------------
_ZNK10cryptonote16subaddress_index7is_zeroEv:
   44|    713|    bool is_zero() const { return major == 0 && minor == 0; }
  ------------------
  |  Branch (44:35): [True: 443, False: 270]
  |  Branch (44:49): [True: 437, False: 6]
  ------------------

_ZN10cryptonote25tx_extra_merge_mining_tag16serialize_helperC2ERS0_:
  117|    169|      serialize_helper(tx_extra_merge_mining_tag& mm_tag_) : mm_tag(mm_tag_)
  118|    169|      {
  119|    169|      }
_ZN10cryptonote16tx_extra_padding19member_do_serializeI14binary_archiveEEbRT_ILb0EE:
   56|    557|    {
   57|       |      // size - 1 - because of variant tag
   58|  16.8k|      for (size = 1; size <= TX_EXTRA_PADDING_MAX_COUNT; ++size)
  ------------------
  |  |   34|  16.8k|#define TX_EXTRA_PADDING_MAX_COUNT          255
  ------------------
  |  Branch (58:22): [True: 16.8k, False: 6]
  ------------------
   59|  16.8k|      {
   60|  16.8k|        if (ar.eof())
  ------------------
  |  Branch (60:13): [True: 395, False: 16.4k]
  ------------------
   61|    395|          break;
   62|       |
   63|  16.4k|        uint8_t zero;
   64|  16.4k|        if (!::do_serialize(ar, zero))
  ------------------
  |  Branch (64:13): [True: 0, False: 16.4k]
  ------------------
   65|      0|          return false;
   66|       |
   67|  16.4k|        if (0 != zero)
  ------------------
  |  Branch (67:13): [True: 156, False: 16.2k]
  ------------------
   68|    156|          return false;
   69|  16.4k|      }
   70|       |
   71|    401|      return size <= TX_EXTRA_PADDING_MAX_COUNT;
  ------------------
  |  |   34|    401|#define TX_EXTRA_PADDING_MAX_COUNT          255
  ------------------
   72|    557|    }
_ZN10cryptonote16tx_extra_pub_key19member_do_serializeILb0E14binary_archiveEEbRT0_IXT_EE:
   96|  5.07k|    BEGIN_SERIALIZE()
  ------------------
  |  |  157|  5.07k|  bool member_do_serialize(Archive<W> &ar) {
  ------------------
   97|  5.07k|      FIELD(pub_key)
  ------------------
  |  |  226|  5.07k|  do {							\
  |  |  227|  5.07k|    ar.tag(#f);						\
  |  |  228|  5.07k|    bool r = do_serialize(ar, f);			\
  |  |  229|  5.07k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 5.07k]
  |  |  |  Branch (229:15): [True: 41, False: 5.03k]
  |  |  ------------------
  |  |  230|  5.07k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
   98|  5.03k|    END_SERIALIZE()
  ------------------
  |  |  207|  5.03k|  return ar.good();				\
  |  |  208|  5.07k|  }
  ------------------
_ZN10cryptonote14tx_extra_nonce19member_do_serializeILb0E14binary_archiveEEbRT0_IXT_EE:
  105|  11.5k|    BEGIN_SERIALIZE()
  ------------------
  |  |  157|  11.5k|  bool member_do_serialize(Archive<W> &ar) {
  ------------------
  106|  11.5k|      FIELD(nonce)
  ------------------
  |  |  226|  11.5k|  do {							\
  |  |  227|  11.5k|    ar.tag(#f);						\
  |  |  228|  11.5k|    bool r = do_serialize(ar, f);			\
  |  |  229|  11.5k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 32, False: 11.4k]
  |  |  |  Branch (229:15): [True: 3, False: 11.4k]
  |  |  ------------------
  |  |  230|  11.5k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  107|  11.4k|      if(TX_EXTRA_NONCE_MAX_COUNT < nonce.size()) return false;
  ------------------
  |  |   35|  11.4k|#define TX_EXTRA_NONCE_MAX_COUNT            255
  ------------------
  |  Branch (107:10): [True: 7, False: 11.4k]
  ------------------
  108|  11.4k|    END_SERIALIZE()
  ------------------
  |  |  207|  11.4k|  return ar.good();				\
  |  |  208|  11.4k|  }
  ------------------
_ZN10cryptonote25tx_extra_merge_mining_tag19member_do_serializeI14binary_archiveEEbRT_ILb0EE:
  133|    143|    {
  134|    143|      std::string field;
  135|    143|      if(!::do_serialize(ar, field))
  ------------------
  |  Branch (135:10): [True: 6, False: 137]
  ------------------
  136|      6|        return false;
  137|       |
  138|    137|      binary_archive<false> iar{epee::strspan<std::uint8_t>(field)};
  139|    137|      serialize_helper helper(*this);
  140|    137|      return ::serialization::serialize(iar, helper);
  141|    143|    }
_ZN10cryptonote25tx_extra_merge_mining_tag16serialize_helper19member_do_serializeILb0E14binary_archiveEEbRT0_IXT_EE:
  121|    137|      BEGIN_SERIALIZE()
  ------------------
  |  |  157|    137|  bool member_do_serialize(Archive<W> &ar) {
  ------------------
  122|    137|        VARINT_FIELD_N("depth", mm_tag.depth)
  ------------------
  |  |  263|    137|  do {						\
  |  |  264|    137|    ar.tag(t);					\
  |  |  265|    137|    ar.serialize_varint(f);			\
  |  |  266|    137|    if (!ar.good()) return false;		\
  |  |  ------------------
  |  |  |  Branch (266:9): [True: 11, False: 126]
  |  |  ------------------
  |  |  267|    137|  } while(0);
  |  |  ------------------
  |  |  |  Branch (267:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  123|    126|        FIELD_N("merkle_root", mm_tag.merkle_root)
  ------------------
  |  |  215|    126|  do {							\
  |  |  216|    126|    ar.tag(t);						\
  |  |  217|    126|    bool r = do_serialize(ar, f VA_ARGS_COMMAPREFIX(__VA_ARGS__)); \
  |  |  218|    126|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (218:9): [True: 0, False: 126]
  |  |  |  Branch (218:15): [True: 27, False: 99]
  |  |  ------------------
  |  |  219|    126|  } while(0);
  |  |  ------------------
  |  |  |  Branch (219:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  124|     99|      END_SERIALIZE()
  ------------------
  |  |  207|     99|  return ar.good();				\
  |  |  208|    126|  }
  ------------------
_ZN10cryptonote28tx_extra_additional_pub_keys19member_do_serializeILb0E14binary_archiveEEbRT0_IXT_EE:
  163|  1.41k|    BEGIN_SERIALIZE()
  ------------------
  |  |  157|  1.41k|  bool member_do_serialize(Archive<W> &ar) {
  ------------------
  164|  1.41k|      FIELD(data)
  ------------------
  |  |  226|  1.41k|  do {							\
  |  |  227|  1.41k|    ar.tag(#f);						\
  |  |  228|  1.41k|    bool r = do_serialize(ar, f);			\
  |  |  229|  1.41k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 28, False: 1.38k]
  |  |  |  Branch (229:15): [True: 0, False: 1.38k]
  |  |  ------------------
  |  |  230|  1.41k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  165|  1.38k|    END_SERIALIZE()
  ------------------
  |  |  207|  1.38k|  return ar.good();				\
  |  |  208|  1.41k|  }
  ------------------
_ZN10cryptonote29tx_extra_mysterious_minergate19member_do_serializeILb0E14binary_archiveEEbRT0_IXT_EE:
  172|  2.91k|    BEGIN_SERIALIZE()
  ------------------
  |  |  157|  2.91k|  bool member_do_serialize(Archive<W> &ar) {
  ------------------
  173|  2.91k|      FIELD(data)
  ------------------
  |  |  226|  2.91k|  do {							\
  |  |  227|  2.91k|    ar.tag(#f);						\
  |  |  228|  2.91k|    bool r = do_serialize(ar, f);			\
  |  |  229|  2.91k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 19, False: 2.89k]
  |  |  |  Branch (229:15): [True: 3, False: 2.89k]
  |  |  ------------------
  |  |  230|  2.91k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  174|  2.89k|    END_SERIALIZE()
  ------------------
  |  |  207|  2.89k|  return ar.good();				\
  |  |  208|  2.91k|  }
  ------------------
_ZN10cryptonote16tx_extra_pub_key19member_do_serializeILb1E14binary_archiveEEbRT0_IXT_EE:
   96|    453|    BEGIN_SERIALIZE()
  ------------------
  |  |  157|    453|  bool member_do_serialize(Archive<W> &ar) {
  ------------------
   97|    453|      FIELD(pub_key)
  ------------------
  |  |  226|    453|  do {							\
  |  |  227|    453|    ar.tag(#f);						\
  |  |  228|    453|    bool r = do_serialize(ar, f);			\
  |  |  229|    453|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 453]
  |  |  |  Branch (229:15): [True: 0, False: 453]
  |  |  ------------------
  |  |  230|    453|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
   98|    453|    END_SERIALIZE()
  ------------------
  |  |  207|    453|  return ar.good();				\
  |  |  208|    453|  }
  ------------------
_ZN10cryptonote28tx_extra_additional_pub_keys19member_do_serializeILb1E14binary_archiveEEbRT0_IXT_EE:
  163|    266|    BEGIN_SERIALIZE()
  ------------------
  |  |  157|    266|  bool member_do_serialize(Archive<W> &ar) {
  ------------------
  164|    266|      FIELD(data)
  ------------------
  |  |  226|    266|  do {							\
  |  |  227|    266|    ar.tag(#f);						\
  |  |  228|    266|    bool r = do_serialize(ar, f);			\
  |  |  229|    266|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 266]
  |  |  |  Branch (229:15): [True: 0, False: 266]
  |  |  ------------------
  |  |  230|    266|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  165|    266|    END_SERIALIZE()
  ------------------
  |  |  207|    266|  return ar.good();				\
  |  |  208|    266|  }
  ------------------
_ZN10cryptonote25tx_extra_merge_mining_tag19member_do_serializeI14binary_archiveEEbRT_ILb1EE:
  146|     32|    {
  147|     32|      std::ostringstream oss;
  148|     32|      binary_archive<true> oar(oss);
  149|     32|      serialize_helper helper(*this);
  150|     32|      if(!::do_serialize(oar, helper))
  ------------------
  |  Branch (150:10): [True: 0, False: 32]
  ------------------
  151|      0|        return false;
  152|       |
  153|     32|      std::string field = oss.str();
  154|     32|      return ::serialization::serialize(ar, field);
  155|     32|    }
_ZN10cryptonote25tx_extra_merge_mining_tag16serialize_helper19member_do_serializeILb1E14binary_archiveEEbRT0_IXT_EE:
  121|     32|      BEGIN_SERIALIZE()
  ------------------
  |  |  157|     32|  bool member_do_serialize(Archive<W> &ar) {
  ------------------
  122|     32|        VARINT_FIELD_N("depth", mm_tag.depth)
  ------------------
  |  |  263|     32|  do {						\
  |  |  264|     32|    ar.tag(t);					\
  |  |  265|     32|    ar.serialize_varint(f);			\
  |  |  266|     32|    if (!ar.good()) return false;		\
  |  |  ------------------
  |  |  |  Branch (266:9): [True: 0, False: 32]
  |  |  ------------------
  |  |  267|     32|  } while(0);
  |  |  ------------------
  |  |  |  Branch (267:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  123|     32|        FIELD_N("merkle_root", mm_tag.merkle_root)
  ------------------
  |  |  215|     32|  do {							\
  |  |  216|     32|    ar.tag(t);						\
  |  |  217|     32|    bool r = do_serialize(ar, f VA_ARGS_COMMAPREFIX(__VA_ARGS__)); \
  |  |  218|     32|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (218:9): [True: 0, False: 32]
  |  |  |  Branch (218:15): [True: 0, False: 32]
  |  |  ------------------
  |  |  219|     32|  } while(0);
  |  |  ------------------
  |  |  |  Branch (219:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  124|     32|      END_SERIALIZE()
  ------------------
  |  |  207|     32|  return ar.good();				\
  |  |  208|     32|  }
  ------------------
_ZN10cryptonote29tx_extra_mysterious_minergate19member_do_serializeILb1E14binary_archiveEEbRT0_IXT_EE:
  172|    957|    BEGIN_SERIALIZE()
  ------------------
  |  |  157|    957|  bool member_do_serialize(Archive<W> &ar) {
  ------------------
  173|    957|      FIELD(data)
  ------------------
  |  |  226|    957|  do {							\
  |  |  227|    957|    ar.tag(#f);						\
  |  |  228|    957|    bool r = do_serialize(ar, f);			\
  |  |  229|    957|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 957]
  |  |  |  Branch (229:15): [True: 0, False: 957]
  |  |  ------------------
  |  |  230|    957|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  174|    957|    END_SERIALIZE()
  ------------------
  |  |  207|    957|  return ar.good();				\
  |  |  208|    957|  }
  ------------------
_ZN10cryptonote16tx_extra_padding19member_do_serializeI14binary_archiveEEbRT_ILb1EE:
   77|     89|    {
   78|     89|      if(TX_EXTRA_PADDING_MAX_COUNT < size)
  ------------------
  |  |   34|     89|#define TX_EXTRA_PADDING_MAX_COUNT          255
  ------------------
  |  Branch (78:10): [True: 0, False: 89]
  ------------------
   79|      0|        return false;
   80|       |
   81|       |      // i = 1 - because of variant tag
   82|  3.39k|      for (size_t i = 1; i < size; ++i)
  ------------------
  |  Branch (82:26): [True: 3.30k, False: 89]
  ------------------
   83|  3.30k|      {
   84|  3.30k|        uint8_t zero = 0;
   85|  3.30k|        if (!::do_serialize(ar, zero))
  ------------------
  |  Branch (85:13): [True: 0, False: 3.30k]
  ------------------
   86|      0|          return false;
   87|  3.30k|      }
   88|     89|      return true;
   89|     89|    }

_ZN10cryptonote10get_configENS_12network_typeE:
  318|      3|  {
  319|      3|    static const config_t mainnet = {
  320|      3|      ::config::CRYPTONOTE_PUBLIC_ADDRESS_BASE58_PREFIX,
  321|      3|      ::config::CRYPTONOTE_PUBLIC_INTEGRATED_ADDRESS_BASE58_PREFIX,
  322|      3|      ::config::CRYPTONOTE_PUBLIC_SUBADDRESS_BASE58_PREFIX,
  323|      3|      ::config::P2P_DEFAULT_PORT,
  324|      3|      ::config::RPC_DEFAULT_PORT,
  325|      3|      ::config::ZMQ_RPC_DEFAULT_PORT,
  326|      3|      ::config::NETWORK_ID,
  327|      3|      ::config::GENESIS_TX,
  328|      3|      ::config::GENESIS_NONCE
  329|      3|    };
  330|      3|    static const config_t testnet = {
  331|      3|      ::config::testnet::CRYPTONOTE_PUBLIC_ADDRESS_BASE58_PREFIX,
  332|      3|      ::config::testnet::CRYPTONOTE_PUBLIC_INTEGRATED_ADDRESS_BASE58_PREFIX,
  333|      3|      ::config::testnet::CRYPTONOTE_PUBLIC_SUBADDRESS_BASE58_PREFIX,
  334|      3|      ::config::testnet::P2P_DEFAULT_PORT,
  335|      3|      ::config::testnet::RPC_DEFAULT_PORT,
  336|      3|      ::config::testnet::ZMQ_RPC_DEFAULT_PORT,
  337|      3|      ::config::testnet::NETWORK_ID,
  338|      3|      ::config::testnet::GENESIS_TX,
  339|      3|      ::config::testnet::GENESIS_NONCE
  340|      3|    };
  341|      3|    static const config_t stagenet = {
  342|      3|      ::config::stagenet::CRYPTONOTE_PUBLIC_ADDRESS_BASE58_PREFIX,
  343|      3|      ::config::stagenet::CRYPTONOTE_PUBLIC_INTEGRATED_ADDRESS_BASE58_PREFIX,
  344|      3|      ::config::stagenet::CRYPTONOTE_PUBLIC_SUBADDRESS_BASE58_PREFIX,
  345|      3|      ::config::stagenet::P2P_DEFAULT_PORT,
  346|      3|      ::config::stagenet::RPC_DEFAULT_PORT,
  347|      3|      ::config::stagenet::ZMQ_RPC_DEFAULT_PORT,
  348|      3|      ::config::stagenet::NETWORK_ID,
  349|      3|      ::config::stagenet::GENESIS_TX,
  350|      3|      ::config::stagenet::GENESIS_NONCE
  351|      3|    };
  352|      3|    switch (nettype)
  353|      3|    {
  354|      3|      case MAINNET: return mainnet;
  ------------------
  |  Branch (354:7): [True: 3, False: 0]
  ------------------
  355|      0|      case TESTNET: return testnet;
  ------------------
  |  Branch (355:7): [True: 0, False: 3]
  ------------------
  356|      0|      case STAGENET: return stagenet;
  ------------------
  |  Branch (356:7): [True: 0, False: 3]
  ------------------
  357|      0|      case FAKECHAIN: return mainnet;
  ------------------
  |  Branch (357:7): [True: 0, False: 3]
  ------------------
  358|      0|      default: throw std::runtime_error("Invalid network type");
  ------------------
  |  Branch (358:7): [True: 0, False: 3]
  ------------------
  359|      3|    }
  360|      3|  };

_ZN10cryptonote18classify_addressesERKNSt3__16vectorINS_20tx_destination_entryENS0_9allocatorIS2_EEEERKN5boost8optionalINS_22account_public_addressEEERmSE_RSA_:
   53|  1.35k|  {
   54|  1.35k|    num_stdaddresses = 0;
   55|  1.35k|    num_subaddresses = 0;
   56|  1.35k|    std::unordered_set<cryptonote::account_public_address> unique_dst_addresses;
   57|  1.35k|    for(const tx_destination_entry& dst_entr: destinations)
  ------------------
  |  Branch (57:45): [True: 98.9k, False: 1.35k]
  ------------------
   58|  98.9k|    {
   59|  98.9k|      if (change_addr && dst_entr.addr == change_addr)
  ------------------
  |  Branch (59:11): [True: 98.9k, False: 0]
  |  Branch (59:26): [True: 230, False: 98.7k]
  ------------------
   60|    230|        continue;
   61|  98.7k|      if (unique_dst_addresses.count(dst_entr.addr) == 0)
  ------------------
  |  Branch (61:11): [True: 39.2k, False: 59.4k]
  ------------------
   62|  39.2k|      {
   63|  39.2k|        unique_dst_addresses.insert(dst_entr.addr);
   64|  39.2k|        if (dst_entr.is_subaddress)
  ------------------
  |  Branch (64:13): [True: 6.47k, False: 32.7k]
  ------------------
   65|  6.47k|        {
   66|  6.47k|          ++num_subaddresses;
   67|  6.47k|          single_dest_subaddress = dst_entr.addr;
   68|  6.47k|        }
   69|  32.7k|        else
   70|  32.7k|        {
   71|  32.7k|          ++num_stdaddresses;
   72|  32.7k|        }
   73|  39.2k|      }
   74|  98.7k|    }
   75|  1.35k|    LOG_PRINT_L2("destinations include " << num_stdaddresses << " standard addresses and " << num_subaddresses << " subaddresses");
  ------------------
  |  |  103|  1.35k|#define LOG_PRINT_L2(x) MDEBUG(x)
  |  |  ------------------
  |  |  |  |   78|  1.35k|#define MDEBUG(x) MCDEBUG(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|  1.35k|#define MCDEBUG(cat,x) MCLOG(el::Level::Debug,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|  1.35k|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|  1.35k|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|  1.35k|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 1.35k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|  1.35k|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   76|  1.35k|  }
_ZN10cryptonote28get_destination_view_key_pubERKNSt3__16vectorINS_20tx_destination_entryENS0_9allocatorIS2_EEEERKN5boost8optionalINS_22account_public_addressEEE:
  185|    765|  {
  186|    765|    account_public_address addr = {null_pkey, null_pkey};
  187|    765|    size_t count = 0;
  188|    765|    for (const auto &i : destinations)
  ------------------
  |  Branch (188:24): [True: 1.66k, False: 518]
  ------------------
  189|  1.66k|    {
  190|  1.66k|      if (i.amount == 0)
  ------------------
  |  Branch (190:11): [True: 896, False: 771]
  ------------------
  191|    896|        continue;
  192|    771|      if (change_addr && i.addr == *change_addr)
  ------------------
  |  Branch (192:11): [True: 771, False: 0]
  |  Branch (192:26): [True: 20, False: 751]
  ------------------
  193|     20|        continue;
  194|    751|      if (i.addr == addr)
  ------------------
  |  Branch (194:11): [True: 32, False: 719]
  ------------------
  195|     32|        continue;
  196|    719|      if (count > 0)
  ------------------
  |  Branch (196:11): [True: 247, False: 472]
  ------------------
  197|    247|        return null_pkey;
  198|    472|      addr = i.addr;
  199|    472|      ++count;
  200|    472|    }
  201|    518|    if (count == 0 && change_addr)
  ------------------
  |  Branch (201:9): [True: 293, False: 225]
  |  Branch (201:23): [True: 293, False: 0]
  ------------------
  202|    293|      return change_addr->m_view_public_key;
  203|    225|    return addr.m_view_public_key;
  204|    518|  }
_ZN10cryptonote24construct_tx_with_tx_keyERKNS_12account_keysERKNSt3__113unordered_mapIN6crypto10public_keyENS_16subaddress_indexENS3_4hashIS6_EENS3_8equal_toIS6_EENS3_9allocatorINS3_4pairIKS6_S7_EEEEEERNS3_6vectorINS_15tx_source_entryENSC_ISL_EEEERNSK_INS_20tx_destination_entryENSC_ISP_EEEERKN5boost8optionalINS_22account_public_addressEEERKNSK_IhNSC_IhEEEERNS_11transactionERKN4epee7mlockedIN5tools8scrubbedINS5_9ec_scalarEEEEERKNSK_IS1B_NSC_IS1B_EEEEbRKN3rct9RCTConfigEbb:
  207|  1.35k|  {
  208|  1.35k|    hw::device &hwdev = sender_account_keys.get_device();
  209|       |
  210|  1.35k|    if (sources.empty())
  ------------------
  |  Branch (210:9): [True: 0, False: 1.35k]
  ------------------
  211|      0|    {
  212|      0|      LOG_ERROR("Empty sources");
  ------------------
  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  ------------------
  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  213|      0|      return false;
  214|      0|    }
  215|       |
  216|  1.35k|    std::vector<rct::key> amount_keys;
  217|  1.35k|    tx.set_null();
  218|  1.35k|    amount_keys.clear();
  219|       |
  220|  1.35k|    tx.version = rct ? 2 : 1;
  ------------------
  |  Branch (220:18): [True: 24, False: 1.33k]
  ------------------
  221|  1.35k|    tx.unlock_time = 0;
  222|       |
  223|  1.35k|    tx.extra = extra;
  224|  1.35k|    crypto::public_key txkey_pub;
  225|       |
  226|       |    // if we have a stealth payment id, find it and encrypt it with the tx key now
  227|  1.35k|    std::vector<tx_extra_field> tx_extra_fields;
  228|  1.35k|    if (parse_tx_extra(tx.extra, tx_extra_fields))
  ------------------
  |  Branch (228:9): [True: 1.34k, False: 17]
  ------------------
  229|  1.34k|    {
  230|  1.34k|      bool add_dummy_payment_id = true;
  231|  1.34k|      tx_extra_nonce extra_nonce;
  232|  1.34k|      if (find_tx_extra_field_by_type(tx_extra_fields, extra_nonce))
  ------------------
  |  Branch (232:11): [True: 140, False: 1.20k]
  ------------------
  233|    140|      {
  234|    140|        crypto::hash payment_id = null_hash;
  235|    140|        crypto::hash8 payment_id8 = null_hash8;
  236|    140|        if (get_encrypted_payment_id_from_tx_extra_nonce(extra_nonce.nonce, payment_id8))
  ------------------
  |  Branch (236:13): [True: 118, False: 22]
  ------------------
  237|    118|        {
  238|    118|          LOG_PRINT_L2("Encrypting payment id " << payment_id8);
  ------------------
  |  |  103|    118|#define LOG_PRINT_L2(x) MDEBUG(x)
  |  |  ------------------
  |  |  |  |   78|    118|#define MDEBUG(x) MCDEBUG(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|    118|#define MCDEBUG(cat,x) MCLOG(el::Level::Debug,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|    118|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|    118|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|    118|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 118]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|    118|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  239|    118|          crypto::public_key view_key_pub = get_destination_view_key_pub(destinations, change_addr);
  240|    118|          if (view_key_pub == null_pkey)
  ------------------
  |  Branch (240:15): [True: 19, False: 99]
  ------------------
  241|     19|          {
  242|     19|            LOG_ERROR("Destinations have to have exactly one output to support encrypted payment ids");
  ------------------
  |  |  100|     19|#define LOG_ERROR(x) MERROR(x)
  |  |  ------------------
  |  |  |  |   75|     19|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   53|     19|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|     19|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|     19|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|     19|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 19]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|     19|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  243|     19|            return false;
  244|     19|          }
  245|       |
  246|     99|          if (!hwdev.encrypt_payment_id(payment_id8, view_key_pub, tx_key))
  ------------------
  |  Branch (246:15): [True: 7, False: 92]
  ------------------
  247|      7|          {
  248|      7|            LOG_ERROR("Failed to encrypt payment id");
  ------------------
  |  |  100|      7|#define LOG_ERROR(x) MERROR(x)
  |  |  ------------------
  |  |  |  |   75|      7|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   53|      7|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      7|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|      7|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|      7|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 7]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|      7|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  249|      7|            return false;
  250|      7|          }
  251|       |
  252|     92|          std::string extra_nonce;
  253|     92|          set_encrypted_payment_id_to_tx_extra_nonce(extra_nonce, payment_id8);
  254|     92|          remove_field_from_tx_extra(tx.extra, typeid(tx_extra_nonce));
  255|     92|          if (!add_extra_nonce_to_tx_extra(tx.extra, extra_nonce))
  ------------------
  |  Branch (255:15): [True: 0, False: 92]
  ------------------
  256|      0|          {
  257|      0|            LOG_ERROR("Failed to add encrypted payment id to tx extra");
  ------------------
  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  ------------------
  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  258|      0|            return false;
  259|      0|          }
  260|     92|          LOG_PRINT_L1("Encrypted payment ID: " << payment_id8);
  ------------------
  |  |  102|     92|#define LOG_PRINT_L1(x) MINFO(x)
  |  |  ------------------
  |  |  |  |   77|     92|#define MINFO(x) MCINFO(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|     92|#define MCINFO(cat,x) MCLOG(el::Level::Info,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|     92|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|     92|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|     92|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 92]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|     92|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  261|     92|          add_dummy_payment_id = false;
  262|     92|        }
  263|     22|        else if (get_payment_id_from_tx_extra_nonce(extra_nonce.nonce, payment_id))
  ------------------
  |  Branch (263:18): [True: 1, False: 21]
  ------------------
  264|      1|        {
  265|      1|          add_dummy_payment_id = false;
  266|      1|        }
  267|    140|      }
  268|       |
  269|       |      // we don't add one if we've got more than the usual 1 destination plus change
  270|  1.31k|      if (destinations.size() > 2)
  ------------------
  |  Branch (270:11): [True: 584, False: 730]
  ------------------
  271|    584|        add_dummy_payment_id = false;
  272|       |
  273|  1.31k|      if (add_dummy_payment_id)
  ------------------
  |  Branch (273:11): [True: 647, False: 667]
  ------------------
  274|    647|      {
  275|       |        // if we have neither long nor short payment id, add a dummy short one,
  276|       |        // this should end up being the vast majority of txes as time goes on
  277|    647|        std::string extra_nonce;
  278|    647|        crypto::hash8 payment_id8 = null_hash8;
  279|    647|        crypto::public_key view_key_pub = get_destination_view_key_pub(destinations, change_addr);
  280|    647|        if (view_key_pub == null_pkey)
  ------------------
  |  Branch (280:13): [True: 266, False: 381]
  ------------------
  281|    266|        {
  282|    266|          LOG_ERROR("Failed to get key to encrypt dummy payment id with");
  ------------------
  |  |  100|    266|#define LOG_ERROR(x) MERROR(x)
  |  |  ------------------
  |  |  |  |   75|    266|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   53|    266|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|    266|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|    266|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|    266|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 266]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|    266|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  283|    266|        }
  284|    381|        else
  285|    381|        {
  286|    381|          hwdev.encrypt_payment_id(payment_id8, view_key_pub, tx_key);
  287|    381|          set_encrypted_payment_id_to_tx_extra_nonce(extra_nonce, payment_id8);
  288|    381|          if (!add_extra_nonce_to_tx_extra(tx.extra, extra_nonce))
  ------------------
  |  Branch (288:15): [True: 0, False: 381]
  ------------------
  289|      0|          {
  290|      0|            LOG_ERROR("Failed to add dummy encrypted payment id to tx extra");
  ------------------
  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  ------------------
  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  291|       |            // continue anyway
  292|      0|          }
  293|    381|        }
  294|    647|      }
  295|  1.31k|    }
  296|     17|    else
  297|     17|    {
  298|     17|      MWARNING("Failed to parse tx extra");
  ------------------
  |  |   76|     17|#define MWARNING(x) MCWARNING(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  ------------------
  |  |  |  |   54|     17|#define MCWARNING(cat,x) MCLOG(el::Level::Warning,cat, el::Color::Default, x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|     17|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   43|     17|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |   44|     17|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 17]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |   47|     17|  } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  299|     17|      tx_extra_fields.clear();
  300|     17|    }
  301|       |
  302|  1.33k|    struct input_generation_context_data
  303|  1.33k|    {
  304|  1.33k|      keypair in_ephemeral;
  305|  1.33k|    };
  306|  1.33k|    std::vector<input_generation_context_data> in_contexts;
  307|       |
  308|  1.33k|    uint64_t summary_inputs_money = 0;
  309|       |    //fill inputs
  310|  1.33k|    int idx = -1;
  311|  1.33k|    for(const tx_source_entry& src_entr:  sources)
  ------------------
  |  Branch (311:40): [True: 1.33k, False: 0]
  ------------------
  312|  1.33k|    {
  313|  1.33k|      ++idx;
  314|  1.33k|      if(src_entr.real_output >= src_entr.outputs.size())
  ------------------
  |  Branch (314:10): [True: 0, False: 1.33k]
  ------------------
  315|      0|      {
  316|      0|        LOG_ERROR("real_output index (" << src_entr.real_output << ")bigger than output_keys.size()=" << src_entr.outputs.size());
  ------------------
  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  ------------------
  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  317|      0|        return false;
  318|      0|      }
  319|  1.33k|      summary_inputs_money += src_entr.amount;
  320|       |
  321|       |      //key_derivation recv_derivation;
  322|  1.33k|      in_contexts.push_back(input_generation_context_data());
  323|  1.33k|      keypair& in_ephemeral = in_contexts.back().in_ephemeral;
  324|  1.33k|      crypto::key_image img;
  325|  1.33k|      const auto& out_key = reinterpret_cast<const crypto::public_key&>(src_entr.outputs[src_entr.real_output].second.dest);
  326|  1.33k|      if(!generate_key_image_helper(sender_account_keys, subaddresses, out_key, src_entr.real_out_tx_key, src_entr.real_out_additional_tx_keys, src_entr.real_output_in_tx_index, in_ephemeral,img, hwdev))
  ------------------
  |  Branch (326:10): [True: 1.33k, False: 0]
  ------------------
  327|  1.33k|      {
  328|  1.33k|        LOG_ERROR("Key image generation failed!");
  ------------------
  |  |  100|  1.33k|#define LOG_ERROR(x) MERROR(x)
  |  |  ------------------
  |  |  |  |   75|  1.33k|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   53|  1.33k|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|  1.33k|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|  1.33k|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|  1.33k|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 1.33k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|  1.33k|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  329|  1.33k|        return false;
  330|  1.33k|      }
  331|       |
  332|       |      //check that derivated key is equal with real output key
  333|      0|      if(!(in_ephemeral.pub == src_entr.outputs[src_entr.real_output].second.dest) )
  ------------------
  |  Branch (333:10): [True: 0, False: 0]
  ------------------
  334|      0|      {
  335|      0|        LOG_ERROR("derived public key mismatch with output public key at index " << idx << ", real out " << src_entr.real_output << "! "<< ENDL << "derived_key:"
  ------------------
  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  ------------------
  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  336|      0|          << string_tools::pod_to_hex(in_ephemeral.pub) << ENDL << "real output_public_key:"
  337|      0|          << string_tools::pod_to_hex(src_entr.outputs[src_entr.real_output].second.dest) );
  338|      0|        LOG_ERROR("amount " << src_entr.amount << ", rct " << src_entr.rct);
  ------------------
  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  ------------------
  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  339|      0|        LOG_ERROR("tx pubkey " << src_entr.real_out_tx_key << ", real_output_in_tx_index " << src_entr.real_output_in_tx_index);
  ------------------
  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  ------------------
  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  340|      0|        return false;
  341|      0|      }
  342|       |
  343|       |      //put key image into tx input
  344|      0|      txin_to_key input_to_key;
  345|      0|      input_to_key.amount = src_entr.amount;
  346|      0|      input_to_key.k_image = img;
  347|       |
  348|       |      //fill outputs array and use relative offsets
  349|      0|      for(const tx_source_entry::output_entry& out_entry: src_entr.outputs)
  ------------------
  |  Branch (349:57): [True: 0, False: 0]
  ------------------
  350|      0|        input_to_key.key_offsets.push_back(out_entry.first);
  351|       |
  352|      0|      input_to_key.key_offsets = absolute_output_offsets_to_relative(input_to_key.key_offsets);
  353|      0|      tx.vin.push_back(input_to_key);
  354|      0|    }
  355|       |
  356|      0|    if (shuffle_outs)
  ------------------
  |  Branch (356:9): [True: 0, False: 0]
  ------------------
  357|      0|    {
  358|      0|      std::shuffle(destinations.begin(), destinations.end(), crypto::random_device{});
  359|      0|    }
  360|       |
  361|       |    // sort ins by their key image
  362|      0|    std::vector<size_t> ins_order(sources.size());
  363|      0|    for (size_t n = 0; n < sources.size(); ++n)
  ------------------
  |  Branch (363:24): [True: 0, False: 0]
  ------------------
  364|      0|      ins_order[n] = n;
  365|      0|    std::sort(ins_order.begin(), ins_order.end(), [&](const size_t i0, const size_t i1) {
  366|      0|      const txin_to_key &tk0 = boost::get<txin_to_key>(tx.vin[i0]);
  367|      0|      const txin_to_key &tk1 = boost::get<txin_to_key>(tx.vin[i1]);
  368|      0|      return memcmp(&tk0.k_image, &tk1.k_image, sizeof(tk0.k_image)) > 0;
  369|      0|    });
  370|      0|    tools::apply_permutation(ins_order, [&] (size_t i0, size_t i1) {
  371|      0|      std::swap(tx.vin[i0], tx.vin[i1]);
  372|      0|      std::swap(in_contexts[i0], in_contexts[i1]);
  373|      0|      std::swap(sources[i0], sources[i1]);
  374|      0|    });
  375|       |
  376|       |    // figure out if we need to make additional tx pubkeys
  377|      0|    size_t num_stdaddresses = 0;
  378|      0|    size_t num_subaddresses = 0;
  379|      0|    account_public_address single_dest_subaddress;
  380|      0|    classify_addresses(destinations, change_addr, num_stdaddresses, num_subaddresses, single_dest_subaddress);
  381|       |
  382|       |    // if this is a single-destination transfer to a subaddress, we set the tx pubkey to R=s*D
  383|      0|    if (num_stdaddresses == 0 && num_subaddresses == 1)
  ------------------
  |  Branch (383:9): [True: 0, False: 0]
  |  Branch (383:34): [True: 0, False: 0]
  ------------------
  384|      0|    {
  385|      0|      txkey_pub = rct::rct2pk(hwdev.scalarmultKey(rct::pk2rct(single_dest_subaddress.m_spend_public_key), rct::sk2rct(tx_key)));
  386|      0|    }
  387|      0|    else
  388|      0|    {
  389|      0|      txkey_pub = rct::rct2pk(hwdev.scalarmultBase(rct::sk2rct(tx_key)));
  390|      0|    }
  391|      0|    remove_field_from_tx_extra(tx.extra, typeid(tx_extra_pub_key));
  392|      0|    add_tx_pub_key_to_extra(tx, txkey_pub);
  393|       |
  394|      0|    std::vector<crypto::public_key> additional_tx_public_keys;
  395|       |
  396|       |    // we don't need to include additional tx keys if:
  397|       |    //   - all the destinations are standard addresses
  398|       |    //   - there's only one destination which is a subaddress
  399|      0|    bool need_additional_txkeys = num_subaddresses > 0 && (num_stdaddresses > 0 || num_subaddresses > 1);
  ------------------
  |  Branch (399:35): [True: 0, False: 0]
  |  Branch (399:60): [True: 0, False: 0]
  |  Branch (399:84): [True: 0, False: 0]
  ------------------
  400|      0|    if (need_additional_txkeys)
  ------------------
  |  Branch (400:9): [True: 0, False: 0]
  ------------------
  401|      0|      CHECK_AND_ASSERT_MES(destinations.size() == additional_tx_keys.size(), false, "Wrong amount of additional tx keys");
  ------------------
  |  |  183|      0|#define CHECK_AND_ASSERT_MES(expr, fail_ret_val, message)   do{if(!(expr)) {LOG_ERROR(message); return fail_ret_val;};}while(0)
  |  |  ------------------
  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (183:67): [True: 0, False: 0]
  |  |  |  Branch (183:126): [Folded - Ignored]
  |  |  ------------------
  ------------------
  402|       |
  403|      0|    uint64_t summary_outs_money = 0;
  404|       |    //fill outputs
  405|      0|    size_t output_index = 0;
  406|      0|    for(const tx_destination_entry& dst_entr: destinations)
  ------------------
  |  Branch (406:45): [True: 0, False: 0]
  ------------------
  407|      0|    {
  408|      0|      CHECK_AND_ASSERT_MES(dst_entr.amount > 0 || tx.version > 1, false, "Destination with wrong amount: " << dst_entr.amount);
  ------------------
  |  |  183|      0|#define CHECK_AND_ASSERT_MES(expr, fail_ret_val, message)   do{if(!(expr)) {LOG_ERROR(message); return fail_ret_val;};}while(0)
  |  |  ------------------
  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (183:69): [True: 0, False: 0]
  |  |  |  Branch (183:69): [True: 0, False: 0]
  |  |  |  Branch (183:126): [Folded - Ignored]
  |  |  ------------------
  ------------------
  409|      0|      crypto::public_key out_eph_public_key;
  410|      0|      crypto::view_tag view_tag;
  411|       |
  412|      0|      hwdev.generate_output_ephemeral_keys(tx.version,sender_account_keys, txkey_pub, tx_key,
  413|      0|                                           dst_entr, change_addr, output_index,
  414|      0|                                           need_additional_txkeys, additional_tx_keys,
  415|      0|                                           additional_tx_public_keys, amount_keys, out_eph_public_key,
  416|      0|                                           use_view_tags, view_tag);
  417|       |
  418|      0|      tx_out out;
  419|      0|      cryptonote::set_tx_out(dst_entr.amount, out_eph_public_key, use_view_tags, view_tag, out);
  420|      0|      tx.vout.push_back(out);
  421|      0|      output_index++;
  422|      0|      summary_outs_money += dst_entr.amount;
  423|      0|    }
  424|      0|    CHECK_AND_ASSERT_MES(additional_tx_public_keys.size() == additional_tx_keys.size(), false, "Internal error creating additional public keys");
  ------------------
  |  |  183|      0|#define CHECK_AND_ASSERT_MES(expr, fail_ret_val, message)   do{if(!(expr)) {LOG_ERROR(message); return fail_ret_val;};}while(0)
  |  |  ------------------
  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (183:67): [True: 0, False: 0]
  |  |  |  Branch (183:126): [Folded - Ignored]
  |  |  ------------------
  ------------------
  425|       |
  426|      0|    remove_field_from_tx_extra(tx.extra, typeid(tx_extra_additional_pub_keys));
  427|       |
  428|      0|    LOG_PRINT_L2("tx pubkey: " << txkey_pub);
  ------------------
  |  |  103|      0|#define LOG_PRINT_L2(x) MDEBUG(x)
  |  |  ------------------
  |  |  |  |   78|      0|#define MDEBUG(x) MCDEBUG(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|      0|#define MCDEBUG(cat,x) MCLOG(el::Level::Debug,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  429|      0|    if (need_additional_txkeys)
  ------------------
  |  Branch (429:9): [True: 0, False: 0]
  ------------------
  430|      0|    {
  431|      0|      LOG_PRINT_L2("additional tx pubkeys: ");
  ------------------
  |  |  103|      0|#define LOG_PRINT_L2(x) MDEBUG(x)
  |  |  ------------------
  |  |  |  |   78|      0|#define MDEBUG(x) MCDEBUG(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|      0|#define MCDEBUG(cat,x) MCLOG(el::Level::Debug,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  432|      0|      for (size_t i = 0; i < additional_tx_public_keys.size(); ++i)
  ------------------
  |  Branch (432:26): [True: 0, False: 0]
  ------------------
  433|      0|        LOG_PRINT_L2(additional_tx_public_keys[i]);
  ------------------
  |  |  103|      0|#define LOG_PRINT_L2(x) MDEBUG(x)
  |  |  ------------------
  |  |  |  |   78|      0|#define MDEBUG(x) MCDEBUG(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|      0|#define MCDEBUG(cat,x) MCLOG(el::Level::Debug,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  434|      0|      add_additional_tx_pub_keys_to_extra(tx.extra, additional_tx_public_keys);
  435|      0|    }
  436|       |
  437|      0|    if (!sort_tx_extra(tx.extra, tx.extra))
  ------------------
  |  Branch (437:9): [True: 0, False: 0]
  ------------------
  438|      0|      return false;
  439|       |
  440|      0|    CHECK_AND_ASSERT_MES(tx.extra.size() <= MAX_TX_EXTRA_SIZE, false, "TX extra size (" << tx.extra.size() << ") is greater than max allowed (" << MAX_TX_EXTRA_SIZE << ")");
  ------------------
  |  |  183|      0|#define CHECK_AND_ASSERT_MES(expr, fail_ret_val, message)   do{if(!(expr)) {LOG_ERROR(message); return fail_ret_val;};}while(0)
  |  |  ------------------
  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (183:67): [True: 0, False: 0]
  |  |  |  Branch (183:126): [Folded - Ignored]
  |  |  ------------------
  ------------------
  441|       |
  442|       |    //check money
  443|      0|    if(summary_outs_money > summary_inputs_money )
  ------------------
  |  Branch (443:8): [True: 0, False: 0]
  ------------------
  444|      0|    {
  445|      0|      LOG_ERROR("Transaction inputs money ("<< summary_inputs_money << ") less than outputs money (" << summary_outs_money << ")");
  ------------------
  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  ------------------
  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  446|      0|      return false;
  447|      0|    }
  448|       |
  449|       |    // check for watch only wallet
  450|      0|    bool zero_secret_key = true;
  451|      0|    for (size_t i = 0; i < sizeof(sender_account_keys.m_spend_secret_key); ++i)
  ------------------
  |  Branch (451:24): [True: 0, False: 0]
  ------------------
  452|      0|      zero_secret_key &= (sender_account_keys.m_spend_secret_key.data[i] == 0);
  453|      0|    if (zero_secret_key)
  ------------------
  |  Branch (453:9): [True: 0, False: 0]
  ------------------
  454|      0|    {
  455|      0|      MDEBUG("Null secret key, skipping signatures");
  ------------------
  |  |   78|      0|#define MDEBUG(x) MCDEBUG(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  ------------------
  |  |  |  |   56|      0|#define MCDEBUG(cat,x) MCLOG(el::Level::Debug,cat, el::Color::Default, x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  456|      0|    }
  457|       |
  458|      0|    if (tx.version == 1)
  ------------------
  |  Branch (458:9): [True: 0, False: 0]
  ------------------
  459|      0|    {
  460|       |      //generate ring signatures
  461|      0|      crypto::hash tx_prefix_hash;
  462|      0|      get_transaction_prefix_hash(tx, tx_prefix_hash);
  463|       |
  464|      0|      std::stringstream ss_ring_s;
  465|      0|      size_t i = 0;
  466|      0|      for(const tx_source_entry& src_entr:  sources)
  ------------------
  |  Branch (466:42): [True: 0, False: 0]
  ------------------
  467|      0|      {
  468|      0|        ss_ring_s << "pub_keys:" << ENDL;
  ------------------
  |  |  151|      0|#define ENDL std::endl
  ------------------
  469|      0|        std::vector<const crypto::public_key*> keys_ptrs;
  470|      0|        std::vector<crypto::public_key> keys(src_entr.outputs.size());
  471|      0|        size_t ii = 0;
  472|      0|        for(const tx_source_entry::output_entry& o: src_entr.outputs)
  ------------------
  |  Branch (472:51): [True: 0, False: 0]
  ------------------
  473|      0|        {
  474|      0|          keys[ii] = rct2pk(o.second.dest);
  475|      0|          keys_ptrs.push_back(&keys[ii]);
  476|      0|          ss_ring_s << o.second.dest << ENDL;
  ------------------
  |  |  151|      0|#define ENDL std::endl
  ------------------
  477|      0|          ++ii;
  478|      0|        }
  479|       |
  480|      0|        tx.signatures.push_back(std::vector<crypto::signature>());
  481|      0|        std::vector<crypto::signature>& sigs = tx.signatures.back();
  482|      0|        sigs.resize(src_entr.outputs.size());
  483|      0|        if (!zero_secret_key)
  ------------------
  |  Branch (483:13): [True: 0, False: 0]
  ------------------
  484|      0|          crypto::generate_ring_signature(tx_prefix_hash, boost::get<txin_to_key>(tx.vin[i]).k_image, keys_ptrs, in_contexts[i].in_ephemeral.sec, src_entr.real_output, sigs.data());
  485|      0|        ss_ring_s << "signatures:" << ENDL;
  ------------------
  |  |  151|      0|#define ENDL std::endl
  ------------------
  486|      0|        std::for_each(sigs.begin(), sigs.end(), [&](const crypto::signature& s){ss_ring_s << s << ENDL;});
  487|      0|        ss_ring_s << "prefix_hash:" << tx_prefix_hash << ENDL << "in_ephemeral_key: " << crypto::secret_key_explicit_print_ref{in_contexts[i].in_ephemeral.sec} << ENDL << "real_output: " << src_entr.real_output << ENDL;
  ------------------
  |  |  151|      0|#define ENDL std::endl
  ------------------
                      ss_ring_s << "prefix_hash:" << tx_prefix_hash << ENDL << "in_ephemeral_key: " << crypto::secret_key_explicit_print_ref{in_contexts[i].in_ephemeral.sec} << ENDL << "real_output: " << src_entr.real_output << ENDL;
  ------------------
  |  |  151|      0|#define ENDL std::endl
  ------------------
                      ss_ring_s << "prefix_hash:" << tx_prefix_hash << ENDL << "in_ephemeral_key: " << crypto::secret_key_explicit_print_ref{in_contexts[i].in_ephemeral.sec} << ENDL << "real_output: " << src_entr.real_output << ENDL;
  ------------------
  |  |  151|      0|#define ENDL std::endl
  ------------------
  488|      0|        i++;
  489|      0|      }
  490|       |
  491|      0|      MCINFO("construct_tx", "transaction_created: " << get_transaction_hash(tx) << ENDL << obj_to_json_str(tx) << ENDL << ss_ring_s.str());
  ------------------
  |  |   55|      0|#define MCINFO(cat,x) MCLOG(el::Level::Info,cat, el::Color::Default, x)
  |  |  ------------------
  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  492|      0|    }
  493|      0|    else
  494|      0|    {
  495|      0|      size_t n_total_outs = sources[0].outputs.size(); // only for non-simple rct
  496|       |
  497|       |      // the non-simple version is slightly smaller, but assumes all real inputs
  498|       |      // are on the same index, so can only be used if there just one ring.
  499|      0|      bool use_simple_rct = sources.size() > 1 || rct_config.range_proof_type != rct::RangeProofBorromean;
  ------------------
  |  Branch (499:29): [True: 0, False: 0]
  |  Branch (499:51): [True: 0, False: 0]
  ------------------
  500|       |
  501|      0|      if (!use_simple_rct)
  ------------------
  |  Branch (501:11): [True: 0, False: 0]
  ------------------
  502|      0|      {
  503|       |        // non simple ringct requires all real inputs to be at the same index for all inputs
  504|      0|        for(const tx_source_entry& src_entr:  sources)
  ------------------
  |  Branch (504:44): [True: 0, False: 0]
  ------------------
  505|      0|        {
  506|      0|          if(src_entr.real_output != sources.begin()->real_output)
  ------------------
  |  Branch (506:14): [True: 0, False: 0]
  ------------------
  507|      0|          {
  508|      0|            LOG_ERROR("All inputs must have the same index for non-simple ringct");
  ------------------
  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  ------------------
  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  509|      0|            return false;
  510|      0|          }
  511|      0|        }
  512|       |
  513|       |        // enforce same mixin for all outputs
  514|      0|        for (size_t i = 1; i < sources.size(); ++i) {
  ------------------
  |  Branch (514:28): [True: 0, False: 0]
  ------------------
  515|      0|          if (n_total_outs != sources[i].outputs.size()) {
  ------------------
  |  Branch (515:15): [True: 0, False: 0]
  ------------------
  516|      0|            LOG_ERROR("Non-simple ringct transaction has varying ring size");
  ------------------
  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  ------------------
  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  517|      0|            return false;
  518|      0|          }
  519|      0|        }
  520|      0|      }
  521|       |
  522|      0|      uint64_t amount_in = 0, amount_out = 0;
  523|      0|      rct::ctkeyV inSk;
  524|      0|      inSk.reserve(sources.size());
  525|       |      // mixRing indexing is done the other way round for simple
  526|      0|      rct::ctkeyM mixRing(use_simple_rct ? sources.size() : n_total_outs);
  ------------------
  |  Branch (526:27): [True: 0, False: 0]
  ------------------
  527|      0|      rct::keyV destinations;
  528|      0|      std::vector<uint64_t> inamounts, outamounts;
  529|      0|      std::vector<unsigned int> index;
  530|      0|      for (size_t i = 0; i < sources.size(); ++i)
  ------------------
  |  Branch (530:26): [True: 0, False: 0]
  ------------------
  531|      0|      {
  532|      0|        rct::ctkey ctkey;
  533|      0|        amount_in += sources[i].amount;
  534|      0|        inamounts.push_back(sources[i].amount);
  535|      0|        index.push_back(sources[i].real_output);
  536|       |        // inSk: (secret key, mask)
  537|      0|        ctkey.dest = rct::sk2rct(in_contexts[i].in_ephemeral.sec);
  538|      0|        ctkey.mask = sources[i].mask;
  539|      0|        inSk.push_back(ctkey);
  540|      0|        memwipe(&ctkey, sizeof(rct::ctkey));
  541|       |        // inPk: (public key, commitment)
  542|       |        // will be done when filling in mixRing
  543|      0|      }
  544|      0|      for (size_t i = 0; i < tx.vout.size(); ++i)
  ------------------
  |  Branch (544:26): [True: 0, False: 0]
  ------------------
  545|      0|      {
  546|      0|        crypto::public_key output_public_key;
  547|      0|        get_output_public_key(tx.vout[i], output_public_key);
  548|      0|        destinations.push_back(rct::pk2rct(output_public_key));
  549|      0|        outamounts.push_back(tx.vout[i].amount);
  550|      0|        amount_out += tx.vout[i].amount;
  551|      0|      }
  552|       |
  553|      0|      if (use_simple_rct)
  ------------------
  |  Branch (553:11): [True: 0, False: 0]
  ------------------
  554|      0|      {
  555|       |        // mixRing indexing is done the other way round for simple
  556|      0|        for (size_t i = 0; i < sources.size(); ++i)
  ------------------
  |  Branch (556:28): [True: 0, False: 0]
  ------------------
  557|      0|        {
  558|      0|          mixRing[i].resize(sources[i].outputs.size());
  559|      0|          for (size_t n = 0; n < sources[i].outputs.size(); ++n)
  ------------------
  |  Branch (559:30): [True: 0, False: 0]
  ------------------
  560|      0|          {
  561|      0|            mixRing[i][n] = sources[i].outputs[n].second;
  562|      0|          }
  563|      0|        }
  564|      0|      }
  565|      0|      else
  566|      0|      {
  567|      0|        for (size_t i = 0; i < n_total_outs; ++i) // same index assumption
  ------------------
  |  Branch (567:28): [True: 0, False: 0]
  ------------------
  568|      0|        {
  569|      0|          mixRing[i].resize(sources.size());
  570|      0|          for (size_t n = 0; n < sources.size(); ++n)
  ------------------
  |  Branch (570:30): [True: 0, False: 0]
  ------------------
  571|      0|          {
  572|      0|            mixRing[i][n] = sources[n].outputs[i].second;
  573|      0|          }
  574|      0|        }
  575|      0|      }
  576|       |
  577|       |      // fee
  578|      0|      if (!use_simple_rct && amount_in > amount_out)
  ------------------
  |  Branch (578:11): [True: 0, False: 0]
  |  Branch (578:30): [True: 0, False: 0]
  ------------------
  579|      0|        outamounts.push_back(amount_in - amount_out);
  580|       |
  581|       |      // zero out all amounts to mask rct outputs, real amounts are now encrypted
  582|      0|      for (size_t i = 0; i < tx.vin.size(); ++i)
  ------------------
  |  Branch (582:26): [True: 0, False: 0]
  ------------------
  583|      0|      {
  584|      0|        if (sources[i].rct)
  ------------------
  |  Branch (584:13): [True: 0, False: 0]
  ------------------
  585|      0|          boost::get<txin_to_key>(tx.vin[i]).amount = 0;
  586|      0|      }
  587|      0|      for (size_t i = 0; i < tx.vout.size(); ++i)
  ------------------
  |  Branch (587:26): [True: 0, False: 0]
  ------------------
  588|      0|        tx.vout[i].amount = 0;
  589|       |
  590|      0|      crypto::hash tx_prefix_hash;
  591|      0|      get_transaction_prefix_hash(tx, tx_prefix_hash, hwdev);
  592|      0|      rct::ctkeyV outSk;
  593|      0|      if (use_simple_rct)
  ------------------
  |  Branch (593:11): [True: 0, False: 0]
  ------------------
  594|      0|        tx.rct_signatures = rct::genRctSimple(rct::hash2rct(tx_prefix_hash), inSk, destinations, inamounts, outamounts, amount_in - amount_out, mixRing, amount_keys, index, outSk, rct_config, hwdev);
  595|      0|      else
  596|      0|        tx.rct_signatures = rct::genRct(rct::hash2rct(tx_prefix_hash), inSk, destinations, outamounts, mixRing, amount_keys, sources[0].real_output, outSk, rct_config, hwdev); // same index assumption
  597|      0|      memwipe(inSk.data(), inSk.size() * sizeof(rct::ctkey));
  598|       |
  599|      0|      CHECK_AND_ASSERT_MES(tx.vout.size() == outSk.size(), false, "outSk size does not match vout");
  ------------------
  |  |  183|      0|#define CHECK_AND_ASSERT_MES(expr, fail_ret_val, message)   do{if(!(expr)) {LOG_ERROR(message); return fail_ret_val;};}while(0)
  |  |  ------------------
  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (183:67): [True: 0, False: 0]
  |  |  |  Branch (183:126): [Folded - Ignored]
  |  |  ------------------
  ------------------
  600|       |
  601|      0|      MCINFO("construct_tx", "transaction_created: " << get_transaction_hash(tx) << ENDL << obj_to_json_str(tx) << ENDL);
  ------------------
  |  |   55|      0|#define MCINFO(cat,x) MCLOG(el::Level::Info,cat, el::Color::Default, x)
  |  |  ------------------
  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  602|      0|    }
  603|       |
  604|      0|    tx.invalidate_hashes();
  605|       |
  606|      0|    return true;
  607|      0|  }
_ZN10cryptonote27construct_tx_and_get_tx_keyERKNS_12account_keysERKNSt3__113unordered_mapIN6crypto10public_keyENS_16subaddress_indexENS3_4hashIS6_EENS3_8equal_toIS6_EENS3_9allocatorINS3_4pairIKS6_S7_EEEEEERNS3_6vectorINS_15tx_source_entryENSC_ISL_EEEERNSK_INS_20tx_destination_entryENSC_ISP_EEEERKN5boost8optionalINS_22account_public_addressEEERKNSK_IhNSC_IhEEEERNS_11transactionERN4epee7mlockedIN5tools8scrubbedINS5_9ec_scalarEEEEERNSK_IS1B_NSC_IS1B_EEEEbRKN3rct9RCTConfigEb:
  610|  1.35k|  {
  611|  1.35k|    hw::device &hwdev = sender_account_keys.get_device();
  612|  1.35k|    hwdev.open_tx(tx_key);
  613|  1.35k|    try {
  614|       |      // figure out if we need to make additional tx pubkeys
  615|  1.35k|      size_t num_stdaddresses = 0;
  616|  1.35k|      size_t num_subaddresses = 0;
  617|  1.35k|      account_public_address single_dest_subaddress;
  618|  1.35k|      classify_addresses(destinations, change_addr, num_stdaddresses, num_subaddresses, single_dest_subaddress);
  619|  1.35k|      bool need_additional_txkeys = num_subaddresses > 0 && (num_stdaddresses > 0 || num_subaddresses > 1);
  ------------------
  |  Branch (619:37): [True: 710, False: 647]
  |  Branch (619:62): [True: 587, False: 123]
  |  Branch (619:86): [True: 43, False: 80]
  ------------------
  620|  1.35k|      if (need_additional_txkeys)
  ------------------
  |  Branch (620:11): [True: 630, False: 727]
  ------------------
  621|    630|      {
  622|    630|        additional_tx_keys.clear();
  623|  97.4k|        for (size_t i = 0; i < destinations.size(); ++i)
  ------------------
  |  Branch (623:28): [True: 96.8k, False: 630]
  ------------------
  624|  96.8k|        {
  625|  96.8k|          additional_tx_keys.push_back(keypair::generate(sender_account_keys.get_device()).sec);
  626|  96.8k|        }
  627|    630|      }
  628|       |
  629|  1.35k|      bool shuffle_outs = true;
  630|  1.35k|      bool r = construct_tx_with_tx_key(sender_account_keys, subaddresses, sources, destinations, change_addr, extra, tx, tx_key, additional_tx_keys, rct, rct_config, shuffle_outs, use_view_tags);
  631|  1.35k|      hwdev.close_tx();
  632|  1.35k|      return r;
  633|  1.35k|    } catch(...) {
  634|      0|      hwdev.close_tx();
  635|      0|      throw;
  636|      0|    }
  637|  1.35k|  }
_ZN10cryptonote22generate_genesis_blockERNS_5blockERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEj:
  654|      1|  {
  655|       |    //genesis block
  656|      1|    bl = {};
  657|       |
  658|      1|    blobdata tx_bl;
  659|      1|    bool r = string_tools::parse_hexstr_to_binbuff(genesis_tx, tx_bl);
  660|      1|    CHECK_AND_ASSERT_MES(r, false, "failed to parse coinbase tx from hard coded blob");
  ------------------
  |  |  183|      1|#define CHECK_AND_ASSERT_MES(expr, fail_ret_val, message)   do{if(!(expr)) {LOG_ERROR(message); return fail_ret_val;};}while(0)
  |  |  ------------------
  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (183:67): [True: 0, False: 1]
  |  |  |  Branch (183:126): [Folded - Ignored]
  |  |  ------------------
  ------------------
  661|      1|    r = parse_and_validate_tx_from_blob(tx_bl, bl.miner_tx);
  662|      1|    CHECK_AND_ASSERT_MES(r, false, "failed to parse coinbase tx from hard coded blob");
  ------------------
  |  |  183|      1|#define CHECK_AND_ASSERT_MES(expr, fail_ret_val, message)   do{if(!(expr)) {LOG_ERROR(message); return fail_ret_val;};}while(0)
  |  |  ------------------
  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (183:67): [True: 0, False: 1]
  |  |  |  Branch (183:126): [Folded - Ignored]
  |  |  ------------------
  ------------------
  663|      1|    bl.major_version = CURRENT_BLOCK_MAJOR_VERSION;
  ------------------
  |  |   46|      1|#define CURRENT_BLOCK_MAJOR_VERSION                     1
  ------------------
  664|      1|    bl.minor_version = CURRENT_BLOCK_MINOR_VERSION;
  ------------------
  |  |   47|      1|#define CURRENT_BLOCK_MINOR_VERSION                     0
  ------------------
  665|      1|    bl.timestamp = 0;
  666|      1|    bl.nonce = nonce;
  667|      1|    miner::find_nonce_for_given_block([](const cryptonote::block &b, uint64_t height, const crypto::hash *seed_hash, unsigned int threads, crypto::hash &hash){
  668|      1|      return cryptonote::get_block_longhash(NULL, b, hash, height, seed_hash, threads);
  669|      1|    }, bl, 1, 0, NULL);
  670|      1|    bl.invalidate_hashes();
  671|      1|    return true;
  672|      1|  }
_ZN10cryptonote18get_block_longhashEPKNS_10BlockchainERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERN6crypto4hashEmiPKSD_i:
  681|      1|  {
  682|       |    // block 202612 bug workaround
  683|      1|    if (height == 202612)
  ------------------
  |  Branch (683:9): [True: 0, False: 1]
  ------------------
  684|      0|    {
  685|      0|      static const std::string longhash_202612 = "84f64766475d51837ac9efbef1926486e58563c95a19fef4aec3254f03000000";
  686|      0|      epee::string_tools::hex_to_pod(longhash_202612, res);
  687|      0|      return true;
  688|      0|    }
  689|      1|    if (major_version >= RX_BLOCK_VERSION)
  ------------------
  |  |   95|      1|#define RX_BLOCK_VERSION	12
  ------------------
  |  Branch (689:9): [True: 0, False: 1]
  ------------------
  690|      0|    {
  691|      0|      crypto::hash hash;
  692|      0|      if (pbc != NULL)
  ------------------
  |  Branch (692:11): [True: 0, False: 0]
  ------------------
  693|      0|      {
  694|      0|        const uint64_t seed_height = rx_seedheight(height);
  695|      0|        hash = seed_hash ? *seed_hash : pbc->get_pending_block_id_by_height(seed_height);
  ------------------
  |  Branch (695:16): [True: 0, False: 0]
  ------------------
  696|      0|      } else
  697|      0|      {
  698|      0|        memset(&hash, 0, sizeof(hash));  // only happens when generating genesis block
  699|      0|      }
  700|      0|      rx_slow_hash(hash.data, bd.data(), bd.size(), res.data);
  701|      1|    } else {
  702|      1|      const int pow_variant = major_version >= 7 ? major_version - 6 : 0;
  ------------------
  |  Branch (702:31): [True: 0, False: 1]
  ------------------
  703|      1|      crypto::cn_slow_hash(bd.data(), bd.size(), res, pow_variant, height);
  704|      1|    }
  705|      1|    return true;
  706|      1|  }
_ZN10cryptonote18get_block_longhashEPKNS_10BlockchainERKNS_5blockERN6crypto4hashEmPKS7_i:
  709|      1|  {
  710|      1|    blobdata bd = get_block_hashing_blob(b);
  711|      1|	return get_block_longhash(pbc, bd, res, height, b.major_version, seed_hash, miners);
  712|      1|  }
cryptonote_tx_utils.cpp:_ZZN10cryptonote22generate_genesis_blockERNS_5blockERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEjENK3$_0clERKS0_mPKN6crypto4hashEjRSF_:
  667|      1|    miner::find_nonce_for_given_block([](const cryptonote::block &b, uint64_t height, const crypto::hash *seed_hash, unsigned int threads, crypto::hash &hash){
  668|      1|      return cryptonote::get_block_longhash(NULL, b, hash, height, seed_hash, threads);
  669|      1|    }, bl, 1, 0, NULL);

_ZN10cryptonote20tx_destination_entryC2Ev:
   82|   118k|    tx_destination_entry() : amount(0), addr(AUTO_VAL_INIT(addr)), is_subaddress(false), is_integrated(false) { }
  ------------------
  |  |   36|   118k|#define AUTO_VAL_INIT(v)   boost::value_initialized<decltype(v)>()
  ------------------
_ZN10cryptonote15tx_source_entry19do_serialize_objectILb0E14binary_archiveEEbRT0_IXT_EE:
   58|  3.11k|    BEGIN_SERIALIZE_OBJECT()
  ------------------
  |  |  184|  3.11k|  bool do_serialize_object(Archive<W> &ar){
  ------------------
   59|  3.11k|      FIELD(outputs)
  ------------------
  |  |  226|  3.11k|  do {							\
  |  |  227|  3.11k|    ar.tag(#f);						\
  |  |  228|  3.11k|    bool r = do_serialize(ar, f);			\
  |  |  229|  3.11k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 436, False: 2.67k]
  |  |  |  Branch (229:15): [True: 0, False: 2.67k]
  |  |  ------------------
  |  |  230|  3.11k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
   60|  2.67k|      FIELD(real_output)
  ------------------
  |  |  226|  2.67k|  do {							\
  |  |  227|  2.67k|    ar.tag(#f);						\
  |  |  228|  2.67k|    bool r = do_serialize(ar, f);			\
  |  |  229|  2.67k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 2.67k]
  |  |  |  Branch (229:15): [True: 33, False: 2.64k]
  |  |  ------------------
  |  |  230|  2.67k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
   61|  2.64k|      FIELD(real_out_tx_key)
  ------------------
  |  |  226|  2.64k|  do {							\
  |  |  227|  2.64k|    ar.tag(#f);						\
  |  |  228|  2.64k|    bool r = do_serialize(ar, f);			\
  |  |  229|  2.64k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 2.64k]
  |  |  |  Branch (229:15): [True: 21, False: 2.62k]
  |  |  ------------------
  |  |  230|  2.64k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
   62|  2.62k|      FIELD(real_out_additional_tx_keys)
  ------------------
  |  |  226|  2.62k|  do {							\
  |  |  227|  2.62k|    ar.tag(#f);						\
  |  |  228|  2.62k|    bool r = do_serialize(ar, f);			\
  |  |  229|  2.62k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 21, False: 2.59k]
  |  |  |  Branch (229:15): [True: 0, False: 2.59k]
  |  |  ------------------
  |  |  230|  2.62k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
   63|  2.59k|      FIELD(real_output_in_tx_index)
  ------------------
  |  |  226|  2.59k|  do {							\
  |  |  227|  2.59k|    ar.tag(#f);						\
  |  |  228|  2.59k|    bool r = do_serialize(ar, f);			\
  |  |  229|  2.59k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 2.59k]
  |  |  |  Branch (229:15): [True: 11, False: 2.58k]
  |  |  ------------------
  |  |  230|  2.59k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
   64|  2.58k|      FIELD(amount)
  ------------------
  |  |  226|  2.58k|  do {							\
  |  |  227|  2.58k|    ar.tag(#f);						\
  |  |  228|  2.58k|    bool r = do_serialize(ar, f);			\
  |  |  229|  2.58k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 2.58k]
  |  |  |  Branch (229:15): [True: 17, False: 2.57k]
  |  |  ------------------
  |  |  230|  2.58k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
   65|  2.57k|      FIELD(rct)
  ------------------
  |  |  226|  2.57k|  do {							\
  |  |  227|  2.57k|    ar.tag(#f);						\
  |  |  228|  2.57k|    bool r = do_serialize(ar, f);			\
  |  |  229|  2.57k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 2.57k]
  |  |  |  Branch (229:15): [True: 6, False: 2.56k]
  |  |  ------------------
  |  |  230|  2.57k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
   66|  2.56k|      FIELD(mask)
  ------------------
  |  |  226|  2.56k|  do {							\
  |  |  227|  2.56k|    ar.tag(#f);						\
  |  |  228|  2.56k|    bool r = do_serialize(ar, f);			\
  |  |  229|  2.56k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 2.56k]
  |  |  |  Branch (229:15): [True: 14, False: 2.55k]
  |  |  ------------------
  |  |  230|  2.56k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
   67|  2.55k|      FIELD(multisig_kLRki)
  ------------------
  |  |  226|  2.55k|  do {							\
  |  |  227|  2.55k|    ar.tag(#f);						\
  |  |  228|  2.55k|    bool r = do_serialize(ar, f);			\
  |  |  229|  2.55k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 2.55k]
  |  |  |  Branch (229:15): [True: 21, False: 2.53k]
  |  |  ------------------
  |  |  230|  2.55k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
   68|       |
   69|  2.53k|      if (real_output >= outputs.size())
  ------------------
  |  Branch (69:11): [True: 168, False: 2.36k]
  ------------------
   70|    168|        return false;
   71|  2.36k|    END_SERIALIZE()
  ------------------
  |  |  207|  2.36k|  return ar.good();				\
  |  |  208|  2.53k|  }
  ------------------
_ZN10cryptonote20tx_destination_entry19do_serialize_objectILb0E14binary_archiveEEbRT0_IXT_EE:
  101|   114k|    BEGIN_SERIALIZE_OBJECT()
  ------------------
  |  |  184|   114k|  bool do_serialize_object(Archive<W> &ar){
  ------------------
  102|   114k|      FIELD(original)
  ------------------
  |  |  226|   114k|  do {							\
  |  |  227|   114k|    ar.tag(#f);						\
  |  |  228|   114k|    bool r = do_serialize(ar, f);			\
  |  |  229|   114k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 248, False: 114k]
  |  |  |  Branch (229:15): [True: 1, False: 114k]
  |  |  ------------------
  |  |  230|   114k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  103|   114k|      VARINT_FIELD(amount)
  ------------------
  |  |  252|   114k|  do {						\
  |  |  253|   114k|    ar.tag(#f);					\
  |  |  254|   114k|    ar.serialize_varint(f);			\
  |  |  255|   114k|    if (!ar.good()) return false;		\
  |  |  ------------------
  |  |  |  Branch (255:9): [True: 20, False: 114k]
  |  |  ------------------
  |  |  256|   114k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (256:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  104|   114k|      FIELD(addr)
  ------------------
  |  |  226|   114k|  do {							\
  |  |  227|   114k|    ar.tag(#f);						\
  |  |  228|   114k|    bool r = do_serialize(ar, f);			\
  |  |  229|   114k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 1.26k, False: 112k]
  |  |  |  Branch (229:15): [True: 0, False: 112k]
  |  |  ------------------
  |  |  230|   114k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  105|   112k|      FIELD(is_subaddress)
  ------------------
  |  |  226|   112k|  do {							\
  |  |  227|   112k|    ar.tag(#f);						\
  |  |  228|   112k|    bool r = do_serialize(ar, f);			\
  |  |  229|   112k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 112k]
  |  |  |  Branch (229:15): [True: 3, False: 112k]
  |  |  ------------------
  |  |  230|   112k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  106|   112k|      FIELD(is_integrated)
  ------------------
  |  |  226|   112k|  do {							\
  |  |  227|   112k|    ar.tag(#f);						\
  |  |  228|   112k|    bool r = do_serialize(ar, f);			\
  |  |  229|   112k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 112k]
  |  |  |  Branch (229:15): [True: 12, False: 112k]
  |  |  ------------------
  |  |  230|   112k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  107|   112k|    END_SERIALIZE()
  ------------------
  |  |  207|   112k|  return ar.good();				\
  |  |  208|   112k|  }
  ------------------

_ZN2hw15device_registryC2Ev:
   58|      1|    device_registry::device_registry(){
   59|      1|        hw::core::register_all(registry);
   60|      1|        #ifdef WITH_DEVICE_LEDGER
   61|      1|        hw::ledger::register_all(registry);
   62|      1|        #endif
   63|      1|        atexit(clear_device_registry);
   64|      1|    }
_ZN2hw15device_registry10get_deviceERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   76|      2|    device& device_registry::get_device(const std::string & device_descriptor){
   77|       |        // Device descriptor can contain further specs after first :
   78|      2|        auto delim = device_descriptor.find(':');
   79|      2|        auto device_descriptor_lookup = device_descriptor;
   80|      2|        if (delim != std::string::npos) {
  ------------------
  |  Branch (80:13): [True: 0, False: 2]
  ------------------
   81|      0|            device_descriptor_lookup = device_descriptor.substr(0, delim);
   82|      0|        }
   83|       |
   84|      2|        auto device = registry.find(device_descriptor_lookup);
   85|      2|        if (device == registry.end()) {
  ------------------
  |  Branch (85:13): [True: 0, False: 2]
  ------------------
   86|      0|            MERROR("Device not found in registry: '" << device_descriptor << "'. Known devices: ");
  ------------------
  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  ------------------
  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   87|      0|            for( const auto& sm_pair : registry ) {
  ------------------
  |  Branch (87:38): [True: 0, False: 0]
  ------------------
   88|      0|                MERROR(" - " << sm_pair.first);
  ------------------
  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  ------------------
  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   89|      0|            }
   90|      0|            throw std::runtime_error("device not found: " + device_descriptor);
   91|      0|        }
   92|      2|        return *device->second;
   93|      2|    }
_ZN2hw10get_deviceERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE:
   95|      2|    device& get_device(const std::string & device_descriptor) {
   96|      2|        device_registry *registry = get_device_registry();
   97|      2|        return registry->get_device(device_descriptor);
   98|      2|    }
device.cpp:_ZN2hwL21clear_device_registryEv:
   54|      1|    static void clear_device_registry(){
   55|      1|      get_device_registry(true);
   56|      1|    }
device.cpp:_ZN2hwL19get_device_registryEb:
   44|      3|    static device_registry *get_device_registry(bool clear = false){
   45|      3|      static device_registry *registry = new device_registry();
   46|      3|      if (clear)
  ------------------
  |  Branch (46:11): [True: 1, False: 2]
  ------------------
   47|      1|      {
   48|      1|        delete registry;
   49|      1|        registry = NULL;
   50|      1|      }
   51|      3|      return registry;
   52|      3|    }

_ZN2hw6deviceC2Ev:
   93|      2|        device(): mode(NONE)  {}
_ZN2hw6deviceD2Ev:
   94|      2|        virtual ~device()   {}
_ZN2hw6device8set_modeENS0_11device_modeE:
  129|  23.7k|        virtual bool set_mode(device_mode mode) { this->mode = mode; return true; }
_ZN2hw6device17compute_key_imageERKN10cryptonote12account_keysERKN6crypto10public_keyERKNS5_14key_derivationEmRKNS1_16subaddress_indexERNS1_7keypairERNS5_9key_imageE:
  244|      1|        virtual bool  compute_key_image(const cryptonote::account_keys& ack, const crypto::public_key& out_key, const crypto::key_derivation& recv_derivation, size_t real_output_index, const cryptonote::subaddress_index& received_index, cryptonote::keypair& in_ephemeral, crypto::key_image& ki) { return false; }

_ZN2hw4core14device_defaultC2Ev:
   46|      1|        device_default::device_default() { }
_ZN2hw4core14device_defaultD2Ev:
   48|      1|        device_default::~device_default() { }
_ZN2hw4core14device_default8set_nameERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
   63|      1|        bool device_default::set_name(const std::string &name)  {
   64|      1|            this->name = name;
   65|      1|            return true;
   66|      1|        }
_ZN2hw4core14device_default10disconnectEv:
   81|      1|        bool device_default::disconnect() {
   82|      1|            return true;
   83|      1|        }
_ZN2hw4core14device_default8set_modeENS_6device11device_modeE:
   85|  23.7k|        bool  device_default::set_mode(device_mode mode) {
   86|  23.7k|            return device::set_mode(mode);
   87|  23.7k|        }
_ZN2hw4core14device_default4lockEv:
   93|  23.7k|        void device_default::lock() { }
_ZN2hw4core14device_default6unlockEv:
   97|  23.7k|        void device_default::unlock() { }
_ZN2hw4core14device_default19generate_chacha_keyERKN10cryptonote12account_keysERN4epee7mlockedIN5tools8scrubbedINSt3__15arrayIhLm32EEEEEEEm:
  103|      1|        bool  device_default::generate_chacha_key(const cryptonote::account_keys &keys, crypto::chacha_key &key, uint64_t kdf_rounds) {
  104|      1|            const crypto::secret_key &view_key = keys.m_view_secret_key;
  105|      1|            const crypto::secret_key &spend_key = keys.m_spend_secret_key;
  106|      1|            epee::mlocked<tools::scrubbed_arr<char, sizeof(view_key) + sizeof(spend_key) + 1>> data;
  107|      1|            memcpy(data.data(), &view_key, sizeof(view_key));
  108|      1|            memcpy(data.data() + sizeof(view_key), &spend_key, sizeof(spend_key));
  109|      1|            data[sizeof(data) - 1] = config::HASH_KEY_WALLET;
  110|      1|            crypto::generate_chacha_key(data.data(), sizeof(data), key, kdf_rounds);
  111|      1|            return true;
  112|      1|        }
_ZN2hw4core14device_default28derive_subaddress_public_keyERKN6crypto10public_keyERKNS2_14key_derivationEmRS3_:
  123|  9.97k|        bool device_default::derive_subaddress_public_key(const crypto::public_key &out_key, const crypto::key_derivation &derivation, const std::size_t output_index, crypto::public_key &derived_key) {
  124|  9.97k|            return crypto::wallet::derive_subaddress_public_key(out_key, derivation, output_index,derived_key);
  125|  9.97k|        }
_ZN2hw4core14device_default31get_subaddress_spend_public_keyERKN10cryptonote12account_keysERKNS2_16subaddress_indexE:
  127|    711|        crypto::public_key device_default::get_subaddress_spend_public_key(const cryptonote::account_keys& keys, const cryptonote::subaddress_index &index) {
  128|    711|            if (index.is_zero())
  ------------------
  |  Branch (128:17): [True: 435, False: 276]
  ------------------
  129|    435|              return keys.m_account_address.m_spend_public_key;
  130|       |
  131|       |            // m = Hs(a || index_major || index_minor)
  132|    276|            crypto::secret_key m = get_subaddress_secret_key(keys.m_view_secret_key, index);
  133|       |
  134|       |            // M = m*G
  135|    276|            crypto::public_key M;
  136|    276|            crypto::secret_key_to_public_key(m, M);
  137|       |
  138|       |            // D = B + M
  139|    276|            crypto::public_key D = rct::rct2pk(rct::addKeys(rct::pk2rct(keys.m_account_address.m_spend_public_key), rct::pk2rct(M)));
  140|    276|            return D;
  141|    711|        }
_ZN2hw4core14device_default32get_subaddress_spend_public_keysERKN10cryptonote12account_keysEjjj:
  143|      1|        std::vector<crypto::public_key>  device_default::get_subaddress_spend_public_keys(const cryptonote::account_keys &keys, uint32_t account, uint32_t begin, uint32_t end) {
  144|      1|            CHECK_AND_ASSERT_THROW_MES(begin <= end, "begin > end");
  ------------------
  |  |  175|      1|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0)
  |  |  ------------------
  |  |  |  |  174|      0|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());}
  |  |  |  |  ------------------
  |  |  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (175:58): [True: 0, False: 1]
  |  |  |  Branch (175:105): [Folded - Ignored]
  |  |  ------------------
  ------------------
  145|       |
  146|      1|            std::vector<crypto::public_key> pkeys;
  147|      1|            pkeys.reserve(end - begin);
  148|      1|            cryptonote::subaddress_index index = {account, begin};
  149|       |
  150|      1|            ge_p3 p3;
  151|      1|            ge_cached cached;
  152|      1|            CHECK_AND_ASSERT_THROW_MES(ge_frombytes_vartime(&p3, (const unsigned char*)keys.m_account_address.m_spend_public_key.data) == 0,
  ------------------
  |  |  175|      1|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0)
  |  |  ------------------
  |  |  |  |  174|      0|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());}
  |  |  |  |  ------------------
  |  |  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (175:58): [True: 0, False: 1]
  |  |  |  Branch (175:105): [Folded - Ignored]
  |  |  ------------------
  ------------------
  153|      1|                "ge_frombytes_vartime failed to convert spend public key");
  154|      1|            ge_p3_to_cached(&cached, &p3);
  155|       |
  156|      2|            for (uint32_t idx = begin; idx < end; ++idx)
  ------------------
  |  Branch (156:40): [True: 1, False: 1]
  ------------------
  157|      1|            {
  158|      1|                index.minor = idx;
  159|      1|                if (index.is_zero())
  ------------------
  |  Branch (159:21): [True: 1, False: 0]
  ------------------
  160|      1|                {
  161|      1|                    pkeys.push_back(keys.m_account_address.m_spend_public_key);
  162|      1|                    continue;
  163|      1|                }
  164|      0|                crypto::secret_key m = get_subaddress_secret_key(keys.m_view_secret_key, index);
  165|       |
  166|       |                // M = m*G
  167|      0|                ge_scalarmult_base(&p3, (const unsigned char*)m.data);
  168|       |
  169|       |                // D = B + M
  170|      0|                crypto::public_key D;
  171|      0|                ge_p1p1 p1p1;
  172|      0|                ge_add(&p1p1, &p3, &cached);
  173|      0|                ge_p1p1_to_p3(&p3, &p1p1);
  174|      0|                ge_p3_tobytes((unsigned char*)D.data, &p3);
  175|       |
  176|      0|                pkeys.push_back(D);
  177|      0|            }
  178|      1|            return pkeys;
  179|      1|        }
_ZN2hw4core14device_default25get_subaddress_secret_keyERKN4epee7mlockedIN5tools8scrubbedIN6crypto9ec_scalarEEEEERKN10cryptonote16subaddress_indexE:
  197|    276|        crypto::secret_key  device_default::get_subaddress_secret_key(const crypto::secret_key &a, const cryptonote::subaddress_index &index) {
  198|    276|            char data[sizeof(config::HASH_KEY_SUBADDRESS) + sizeof(crypto::secret_key) + 2 * sizeof(uint32_t)];
  199|    276|            memcpy(data, config::HASH_KEY_SUBADDRESS, sizeof(config::HASH_KEY_SUBADDRESS));
  200|    276|            memcpy(data + sizeof(config::HASH_KEY_SUBADDRESS), &a, sizeof(crypto::secret_key));
  201|    276|            uint32_t idx = SWAP32LE(index.major);
  ------------------
  |  |  277|    276|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|    276|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
  202|    276|            memcpy(data + sizeof(config::HASH_KEY_SUBADDRESS) + sizeof(crypto::secret_key), &idx, sizeof(uint32_t));
  203|    276|            idx = SWAP32LE(index.minor);
  ------------------
  |  |  277|    276|#define SWAP32LE IDENT32
  |  |  ------------------
  |  |  |  |  153|    276|#define IDENT32(x) ((uint32_t) (x))
  |  |  ------------------
  ------------------
  204|    276|            memcpy(data + sizeof(config::HASH_KEY_SUBADDRESS) + sizeof(crypto::secret_key) + sizeof(uint32_t), &idx, sizeof(uint32_t));
  205|    276|            crypto::secret_key m;
  206|    276|            crypto::hash_to_scalar(data, sizeof(data), m);
  207|    276|            return m;
  208|    276|        }
_ZN2hw4core14device_default13generate_keysERN6crypto10public_keyERN4epee7mlockedIN5tools8scrubbedINS2_9ec_scalarEEEEERKSB_b:
  235|  98.2k|        crypto::secret_key  device_default::generate_keys(crypto::public_key &pub, crypto::secret_key &sec, const crypto::secret_key& recovery_key, bool recover) {
  236|  98.2k|            return crypto::generate_keys(pub, sec, recovery_key, recover);
  237|  98.2k|        }
_ZN2hw4core14device_default23generate_key_derivationERKN6crypto10public_keyERKN4epee7mlockedIN5tools8scrubbedINS2_9ec_scalarEEEEERNS2_14key_derivationE:
  239|   125k|        bool device_default::generate_key_derivation(const crypto::public_key &key1, const crypto::secret_key &key2, crypto::key_derivation &derivation) {
  240|   125k|            return crypto::wallet::generate_key_derivation(key1, key2, derivation);
  241|   125k|        }
_ZN2hw4core14device_default17derive_secret_keyERKN6crypto14key_derivationEmRKN4epee7mlockedIN5tools8scrubbedINS2_9ec_scalarEEEEERSC_:
  248|      1|        bool device_default::derive_secret_key(const crypto::key_derivation &derivation, const std::size_t output_index, const crypto::secret_key &base, crypto::secret_key &derived_key){
  249|      1|            crypto::derive_secret_key(derivation, output_index, base, derived_key);
  250|      1|            return true;
  251|      1|        }
_ZN2hw4core14device_default24secret_key_to_public_keyERKN4epee7mlockedIN5tools8scrubbedIN6crypto9ec_scalarEEEEERNS6_10public_keyE:
  257|      1|        bool device_default::secret_key_to_public_key(const crypto::secret_key &sec, crypto::public_key &pub) {
  258|      1|            return crypto::secret_key_to_public_key(sec,pub);
  259|      1|        }
_ZN2hw4core14device_default15derive_view_tagERKN6crypto14key_derivationEmRNS2_8view_tagE:
  266|  1.08k|        bool device_default::derive_view_tag(const crypto::key_derivation &derivation, const std::size_t output_index, crypto::view_tag &view_tag) {
  267|  1.08k|            crypto::derive_view_tag(derivation, output_index, view_tag);
  268|  1.08k|            return true;
  269|  1.08k|        }
_ZN2hw4core14device_default7open_txERN4epee7mlockedIN5tools8scrubbedIN6crypto9ec_scalarEEEEE:
  284|  1.35k|        bool device_default::open_tx(crypto::secret_key &tx_key) {
  285|  1.35k|            cryptonote::keypair txkey = cryptonote::keypair::generate(*this);
  286|  1.35k|            tx_key = txkey.sec;
  287|  1.35k|            return true;
  288|  1.35k|        }
_ZN2hw4core14device_default18encrypt_payment_idERN6crypto5hash8ERKNS2_10public_keyERKN4epee7mlockedIN5tools8scrubbedINS2_9ec_scalarEEEEE:
  354|    480|        bool  device_default::encrypt_payment_id(crypto::hash8 &payment_id, const crypto::public_key &public_key, const crypto::secret_key &secret_key) {
  355|    480|            crypto::key_derivation derivation;
  356|    480|            crypto::hash hash;
  357|    480|            char data[33]; /* A hash, and an extra byte */
  358|       |
  359|    480|            if (!generate_key_derivation(public_key, secret_key, derivation))
  ------------------
  |  Branch (359:17): [True: 189, False: 291]
  ------------------
  360|    189|                return false;
  361|       |
  362|    291|            memcpy(data, &derivation, 32);
  363|    291|            data[32] = config::HASH_KEY_ENCRYPTED_PAYMENT_ID;
  364|    291|            cn_fast_hash(data, 33, hash);
  365|       |
  366|  2.61k|            for (size_t b = 0; b < 8; ++b)
  ------------------
  |  Branch (366:32): [True: 2.32k, False: 291]
  ------------------
  367|  2.32k|                payment_id.data[b] ^= hash.data[b];
  368|       |
  369|    291|            return true;
  370|    480|        }
_ZN2hw4core14device_default8close_txEv:
  442|  1.35k|        bool device_default::close_tx() {
  443|  1.35k|            return true;
  444|  1.35k|        }
_ZN2hw4core12register_allERNSt3__13mapINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_10unique_ptrINS_6deviceENS1_14default_deleteISA_EEEENS1_4lessIS8_EENS6_INS1_4pairIKS8_SD_EEEEEE:
  449|      1|        void register_all(std::map<std::string, std::unique_ptr<device>> &registry) {
  450|      1|            if (!default_core_device) {
  ------------------
  |  Branch (450:17): [True: 1, False: 0]
  ------------------
  451|      1|                default_core_device = new device_default();
  452|      1|                default_core_device->set_name("default_core_device");
  453|       |
  454|      1|            }
  455|      1|            registry.insert(std::make_pair("default", std::unique_ptr<device>(default_core_device)));
  456|      1|        }
device_default.cpp:_ZN2hw4coreadERKN6crypto9ec_scalarE:
   56|    278|        static inline const unsigned char *operator &(const crypto::ec_scalar &scalar) {
   57|    278|            return &reinterpret_cast<const unsigned char &>(scalar);
   58|    278|        }

_ZN2hw2io9device_ioC2Ev:
   43|      1|      device_io()   {};
_ZN2hw2io9device_ioD2Ev:
   44|      1|      ~device_io() {};

_ZN2hw2io13device_io_hidC2Ethjj:
   73|      1|      channel(c), 
   74|      1|      tag(t), 
   75|      1|      packet_size(ps), 
   76|      1|      timeout(to),
   77|      1|      usb_vid(0),
   78|      1|      usb_pid(0),
   79|      1|      usb_device(NULL) {
   80|      1|    }
_ZN2hw2io13device_io_hid10disconnectEv:
  231|      1|    void device_io_hid::disconnect(void)  {
  232|      1|      if (this->usb_device) {
  ------------------
  |  Branch (232:11): [True: 0, False: 1]
  ------------------
  233|      0|        hid_close(this->usb_device);
  234|      0|      }
  235|      1|      this->usb_vid = 0;
  236|      1|      this->usb_pid = 0;
  237|      1|      this->usb_device = NULL;
  238|      1|    }
_ZN2hw2io13device_io_hid7releaseEv:
  240|      1|    void device_io_hid::release()  {
  241|       |      /* Do not exit, as the lib context is global*/
  242|       |      //hid_exit();
  243|      1|    }

_ZN2hw6ledger13device_ledgerC2Ev:
  301|      1|    device_ledger::device_ledger(): hw_device(0x0101, 0x05, 64, 2000) {
  302|      1|      this->id = device_id++;
  303|      1|      this->reset_buffer();      
  304|      1|      this->mode = NONE;
  305|      1|      this->has_view_key = false;
  306|      1|      this->tx_in_progress = false;
  307|      1|      MDEBUG( "Device "<<this->id <<" Created");
  ------------------
  |  |   78|      1|#define MDEBUG(x) MCDEBUG(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  ------------------
  |  |  |  |   56|      1|#define MCDEBUG(cat,x) MCLOG(el::Level::Debug,cat, el::Color::Default, x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      1|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   43|      1|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |   44|      1|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 1]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |   47|      1|  } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  308|      1|    }
_ZN2hw6ledger13device_ledgerD2Ev:
  310|      1|    device_ledger::~device_ledger() {
  311|      1|      this->release();
  312|      1|      MDEBUG( "Device "<<this->id <<" Destroyed");
  ------------------
  |  |   78|      1|#define MDEBUG(x) MCDEBUG(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  ------------------
  |  |  |  |   56|      1|#define MCDEBUG(cat,x) MCLOG(el::Level::Debug,cat, el::Color::Default, x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      1|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   43|      1|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |   44|      1|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 1]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |   47|      1|  } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  313|      1|    }
_ZN2hw6ledger13device_ledger12reset_bufferEv:
  495|      1|    void device_ledger::reset_buffer() {
  496|      1|      this->length_send = 0;
  497|      1|      memset(this->buffer_send, 0, BUFFER_SEND_SIZE);
  ------------------
  |  |  136|      1|    #define BUFFER_SEND_SIZE 262
  ------------------
  498|      1|      this->length_recv = 0;
  499|      1|      memset(this->buffer_recv, 0, BUFFER_RECV_SIZE);
  ------------------
  |  |  137|      1|    #define BUFFER_RECV_SIZE 262
  ------------------
  500|      1|    }
_ZN2hw6ledger13device_ledger8set_nameERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  506|      1|    bool device_ledger::set_name(const std::string & name) {
  507|      1|      this->name = name;
  508|      1|      return true;
  509|      1|    }
_ZN2hw6ledger13device_ledger10disconnectEv:
  553|      1|    bool device_ledger::disconnect() {
  554|      1|      hw_device.disconnect();
  555|      1|      return true;
  556|      1|    }
_ZN2hw6ledger13device_ledger7releaseEv:
  558|      1|    bool device_ledger::release() {
  559|      1|      this->disconnect();
  560|      1|      hw_device.release();
  561|      1|      return true;
  562|      1|    }
_ZN2hw6ledger12register_allERNSt3__13mapINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_10unique_ptrINS_6deviceENS1_14default_deleteISA_EEEENS1_4lessIS8_EENS6_INS1_4pairIKS8_SD_EEEEEE:
 2363|      1|    void register_all(std::map<std::string, std::unique_ptr<device>> &registry) {
 2364|      1|      if (!legder_device) {
  ------------------
  |  Branch (2364:11): [True: 1, False: 0]
  ------------------
 2365|      1|        legder_device = new device_ledger();
 2366|      1|        legder_device->set_name("Ledger");
 2367|      1|      }
 2368|      1|      registry.insert(std::make_pair("Ledger", std::unique_ptr<device>(legder_device)));
 2369|      1|    }

_ZN10hardfork_tC2Ehmhl:
   40|     96|  hardfork_t(uint8_t version, uint64_t height, uint8_t threshold, time_t time): version(version), height(height), threshold(threshold), time(time) {}

_ZN3net4http6client9set_proxyERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
   41|      2|{
   42|      2|  if (address.empty())
  ------------------
  |  Branch (42:7): [True: 2, False: 0]
  ------------------
   43|      2|  {
   44|      2|    set_connector(epee::net_utils::direct_connect{});
   45|      2|  }
   46|      0|  else
   47|      0|  {
   48|      0|    const auto endpoint = get_tcp_endpoint(address);
   49|      0|    if (!endpoint)
  ------------------
  |  Branch (49:9): [True: 0, False: 0]
  ------------------
   50|      0|    {
   51|      0|      auto always_fail = net::socks::connector{boost::asio::ip::tcp::endpoint()};
   52|      0|      set_connector(always_fail);
   53|      0|    }
   54|      0|    else
   55|      0|    {
   56|      0|      set_connector(net::socks::connector{*endpoint});
   57|      0|    }
   58|      0|  }
   59|       |
   60|      2|  disconnect();
   61|       |
   62|      2|  return true;
   63|      2|}
_ZN3net4http14client_factory6createEv:
   66|      2|{
   67|      2|  return std::unique_ptr<epee::net_utils::http::abstract_http_client>(new client());
   68|      2|}

bulletproofs.cc:_ZN3rctL13vector_powersERKNS_3keyEm:
  190|      2|{
  191|      2|  rct::keyV res(n);
  192|      2|  if (n == 0)
  ------------------
  |  Branch (192:7): [True: 0, False: 2]
  ------------------
  193|      0|    return res;
  194|      2|  res[0] = rct::identity();
  195|      2|  if (n == 1)
  ------------------
  |  Branch (195:7): [True: 0, False: 2]
  ------------------
  196|      0|    return res;
  197|      2|  res[1] = x;
  198|    126|  for (size_t i = 2; i < n; ++i)
  ------------------
  |  Branch (198:22): [True: 124, False: 2]
  ------------------
  199|    124|  {
  200|    124|    sc_mul(res[i].bytes, res[i-1].bytes, x.bytes);
  201|    124|  }
  202|      2|  return res;
  203|      2|}
bulletproofs.cc:_ZN3rctL13inner_productERKNSt3__16vectorINS_3keyENS0_9allocatorIS2_EEEES7_:
  252|      2|{
  253|      2|  return inner_product(epee::span<const rct::key>(a.data(), a.size()), epee::span<const rct::key>(b.data(), b.size()));
  254|      2|}
bulletproofs.cc:_ZN3rctL10vector_dupERKNS_3keyEm:
  338|      2|{
  339|      2|  return rct::keyV(N, x);
  340|      2|}
bulletproofs.cc:_ZN3rctL13inner_productERKN4epee4spanIKNS_3keyEEES6_:
  241|      2|{
  242|      2|  CHECK_AND_ASSERT_THROW_MES(a.size() == b.size(), "Incompatible sizes of a and b");
  ------------------
  |  |  175|      2|#define CHECK_AND_ASSERT_THROW_MES(expr, message) do {if(!(expr)) ASSERT_MES_AND_THROW(message);} while(0)
  |  |  ------------------
  |  |  |  |  174|      0|#define ASSERT_MES_AND_THROW(message) {LOG_ERROR(message); std::stringstream ss; ss << message; throw std::runtime_error(ss.str());}
  |  |  |  |  ------------------
  |  |  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (175:58): [True: 0, False: 2]
  |  |  |  Branch (175:105): [Folded - Ignored]
  |  |  ------------------
  ------------------
  243|      2|  rct::key res = rct::zero();
  244|    130|  for (size_t i = 0; i < a.size(); ++i)
  ------------------
  |  Branch (244:22): [True: 128, False: 2]
  ------------------
  245|    128|  {
  246|    128|    sc_muladd(res.bytes, a[i].bytes, b[i].bytes, res.bytes);
  247|    128|  }
  248|      2|  return res;
  249|      2|}

_ZN3rct7addKeysERNS_3keyERKS0_S3_:
  432|    276|    void addKeys(key &AB, const key &A, const key &B) {
  433|    276|        ge_p3 B2, A2;
  434|    276|        CHECK_AND_ASSERT_THROW_MES_L1(ge_frombytes_vartime(&B2, B.bytes) == 0, "ge_frombytes_vartime failed at "+boost::lexical_cast<std::string>(__LINE__));
  ------------------
  |  |   41|    276|#define CHECK_AND_ASSERT_THROW_MES_L1(expr, message) {if(!(expr)) {MWARNING(message); throw std::runtime_error(message);}}
  |  |  ------------------
  |  |  |  |   76|      0|#define MWARNING(x) MCWARNING(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   54|      0|#define MCWARNING(cat,x) MCLOG(el::Level::Warning,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (41:58): [True: 0, False: 276]
  |  |  ------------------
  ------------------
  435|    276|        CHECK_AND_ASSERT_THROW_MES_L1(ge_frombytes_vartime(&A2, A.bytes) == 0, "ge_frombytes_vartime failed at "+boost::lexical_cast<std::string>(__LINE__));
  ------------------
  |  |   41|    276|#define CHECK_AND_ASSERT_THROW_MES_L1(expr, message) {if(!(expr)) {MWARNING(message); throw std::runtime_error(message);}}
  |  |  ------------------
  |  |  |  |   76|      0|#define MWARNING(x) MCWARNING(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   54|      0|#define MCWARNING(cat,x) MCLOG(el::Level::Warning,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (41:58): [True: 0, False: 276]
  |  |  ------------------
  ------------------
  436|    276|        ge_cached tmp2;
  437|    276|        ge_p3_to_cached(&tmp2, &B2);
  438|    276|        ge_p1p1 tmp3;
  439|    276|        ge_add(&tmp3, &A2, &tmp2);
  440|    276|        ge_p1p1_to_p3(&A2, &tmp3);
  441|    276|        ge_p3_tobytes(AB.bytes, &A2);
  442|    276|    }
_ZN3rct7addKeysERKNS_3keyES2_:
  444|    276|    rct::key addKeys(const key &A, const key &B) {
  445|    276|      key k;
  446|    276|      addKeys(k, A, B);
  447|    276|      return k;
  448|    276|    }

_ZN3rct4zeroEv:
   70|      2|    inline key zero() { return Z; }
_ZN3rct8identityEv:
   73|  2.12k|    inline key identity() { return I; }

_ZN3rct14multisig_kLRkiD2Ev:
  120|  8.78k|        ~multisig_kLRki() { memwipe(&k, sizeof(k)); }
_ZN3rct9RCTConfig19do_serialize_objectILb0E14binary_archiveEEbRT0_IXT_EE:
  313|  6.34k|      BEGIN_SERIALIZE_OBJECT()
  ------------------
  |  |  184|  6.34k|  bool do_serialize_object(Archive<W> &ar){
  ------------------
  314|  6.34k|        VERSION_FIELD(0)
  ------------------
  |  |  289|  6.34k|  uint32_t version = v;				\
  |  |  290|  6.34k|  do {						\
  |  |  291|  6.34k|    ar.tag("version");				\
  |  |  292|  6.34k|    ar.serialize_varint(version);		\
  |  |  293|  6.34k|    if (!ar.good()) return false;		\
  |  |  ------------------
  |  |  |  Branch (293:9): [True: 30, False: 6.31k]
  |  |  ------------------
  |  |  294|  6.34k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (294:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  315|  6.31k|        VARINT_FIELD(range_proof_type)
  ------------------
  |  |  252|  6.31k|  do {						\
  |  |  253|  6.31k|    ar.tag(#f);					\
  |  |  254|  6.31k|    ar.serialize_varint(f);			\
  |  |  255|  6.31k|    if (!ar.good()) return false;		\
  |  |  ------------------
  |  |  |  Branch (255:9): [True: 3, False: 6.30k]
  |  |  ------------------
  |  |  256|  6.31k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (256:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  316|  6.30k|        VARINT_FIELD(bp_version)
  ------------------
  |  |  252|  6.30k|  do {						\
  |  |  253|  6.30k|    ar.tag(#f);					\
  |  |  254|  6.30k|    ar.serialize_varint(f);			\
  |  |  255|  6.30k|    if (!ar.good()) return false;		\
  |  |  ------------------
  |  |  |  Branch (255:9): [True: 7, False: 6.30k]
  |  |  ------------------
  |  |  256|  6.30k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (256:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  317|  6.30k|      END_SERIALIZE()
  ------------------
  |  |  207|  6.30k|  return ar.good();				\
  |  |  208|  6.30k|  }
  ------------------
_ZN3rct10rctSigBaseC2Ev:
  330|  1.35k|          type(RCTTypeNull), message{}, mixRing{}, pseudoOuts{}, ecdhInfo{}, outPk{}, txnFee(0)
  331|  1.35k|        {}
device_default.cpp:_ZN3rctL6rct2pkERKNS_3keyE:
  744|    276|    static inline const crypto::public_key &rct2pk(const rct::key &k) { return (const crypto::public_key&)k; }
device_default.cpp:_ZN3rctL6pk2rctERKN6crypto10public_keyE:
  740|    552|    static inline const rct::key &pk2rct(const crypto::public_key &pk) { return (const rct::key&)pk; }

_ZN14binary_archiveILb0EEC2EN4epee4spanIKhEE:
   96|  11.1k|    : base_type(), bytes_(s), begin_(s.begin()), good_(true), varint_bug_backward_compatibility_(false)
   97|  11.1k|  {}
_ZN19binary_archive_baseILb0EEC2Ev:
   68|  11.1k|  explicit binary_archive_base() { }
_ZN19binary_archive_baseILb0EE12begin_objectEv:
   72|   433k|  void begin_object() { }
_ZN19binary_archive_baseILb0EE3tagEPKc:
   71|  1.93M|  void tag(const char *) { }
_ZN14binary_archiveILb0EE16serialize_varintIjEEvRT_:
  139|   198k|  {
  140|   198k|    serialize_uvarint(*(typename boost::make_unsigned<T>::type *)(&v));
  141|   198k|  }
_ZN14binary_archiveILb0EE17serialize_uvarintIjEEvRT_:
  145|   211k|  {
  146|   211k|    auto current = bytes_.cbegin();
  147|   211k|    auto end = bytes_.cend();
  148|   211k|    good_ &= (0 <= tools::read_varint(current, end, v));
  149|   211k|    current = std::min(current, bytes_.cend());
  150|   211k|    bytes_ = {current, std::size_t(bytes_.cend() - current)};
  151|   211k|  }
_ZNK14binary_archiveILb0EE4goodEv:
   99|  6.92M|  bool good() const noexcept { return good_; }
_ZN14binary_archiveILb0EE11begin_arrayERm:
  154|   239k|  {
  155|   239k|    serialize_varint(s);
  156|   239k|  }
_ZN14binary_archiveILb0EE16serialize_varintImEEvRT_:
  139|   800k|  {
  140|   800k|    serialize_uvarint(*(typename boost::make_unsigned<T>::type *)(&v));
  141|   800k|  }
_ZN14binary_archiveILb0EE17serialize_uvarintImEEvRT_:
  145|   800k|  {
  146|   800k|    auto current = bytes_.cbegin();
  147|   800k|    auto end = bytes_.cend();
  148|   800k|    good_ &= (0 <= tools::read_varint(current, end, v));
  149|   800k|    current = std::min(current, bytes_.cend());
  150|   800k|    bytes_ = {current, std::size_t(bytes_.cend() - current)};
  151|   800k|  }
_ZNK14binary_archiveILb0EE15remaining_bytesEv:
  169|   354k|  size_t remaining_bytes() const noexcept { return good() ? bytes_.size() : 0; }
  ------------------
  |  Branch (169:52): [True: 354k, False: 63]
  ------------------
_ZN14binary_archiveILb0EE8set_failEv:
  100|  5.42k|  void set_fail() noexcept { good_ = false; }
_ZN14binary_archiveILb0EE13delimit_arrayEv:
  159|  3.87M|  void delimit_array() { }
_ZN14binary_archiveILb0EE14serialize_blobEPvmPKc:
  131|  1.37M|  {
  132|  1.37M|    const std::size_t actual = bytes_.remove_prefix(len);
  133|  1.37M|    good_ &= (len == actual);
  134|  1.37M|    std::memcpy(buf, bytes_.data() - actual, actual);
  135|  1.37M|  }
_ZN14binary_archiveILb0EE13serialize_intImEEvRT_:
  108|  80.2k|  {
  109|  80.2k|    serialize_uint(*(typename boost::make_unsigned<T>::type *)&v);
  110|  80.2k|  }
_ZN14binary_archiveILb0EE14serialize_uintImEEvRT_:
  118|  80.2k|  {
  119|  80.2k|    const std::size_t actual = bytes_.remove_prefix(sizeof(T));
  120|  80.2k|    good_ &= (actual == sizeof(T));
  121|  80.2k|    if (actual == sizeof(T))
  ------------------
  |  Branch (121:9): [True: 80.0k, False: 210]
  ------------------
  122|  80.0k|    {
  123|  80.0k|      std::memcpy(std::addressof(v), bytes_.data() - sizeof(T), sizeof(T));
  124|  80.0k|      boost::endian::little_to_native_inplace(v); // epee isn't templated
  125|  80.0k|    }
  126|    210|    else
  127|    210|      v = 0; // ensures initialization
  128|  80.2k|  }
_ZN14binary_archiveILb0EE13serialize_intIhEEvRT_:
  108|  3.18M|  {
  109|  3.18M|    serialize_uint(*(typename boost::make_unsigned<T>::type *)&v);
  110|  3.18M|  }
_ZN14binary_archiveILb0EE14serialize_uintIhEEvRT_:
  118|  3.18M|  {
  119|  3.18M|    const std::size_t actual = bytes_.remove_prefix(sizeof(T));
  120|  3.18M|    good_ &= (actual == sizeof(T));
  121|  3.18M|    if (actual == sizeof(T))
  ------------------
  |  Branch (121:9): [True: 3.18M, False: 248]
  ------------------
  122|  3.18M|    {
  123|  3.18M|      std::memcpy(std::addressof(v), bytes_.data() - sizeof(T), sizeof(T));
  124|  3.18M|      boost::endian::little_to_native_inplace(v); // epee isn't templated
  125|  3.18M|    }
  126|    248|    else
  127|    248|      v = 0; // ensures initialization
  128|  3.18M|  }
_ZN14binary_archiveILb0EE16serialize_varintIN3rct14RangeProofTypeEEEvRT_:
  139|  6.31k|  {
  140|  6.31k|    serialize_uvarint(*(typename boost::make_unsigned<T>::type *)(&v));
  141|  6.31k|  }
_ZN14binary_archiveILb0EE16serialize_varintIiEEvRT_:
  139|  6.30k|  {
  140|  6.30k|    serialize_uvarint(*(typename boost::make_unsigned<T>::type *)(&v));
  141|  6.30k|  }
_ZN14binary_archiveILb0EE13serialize_intIjEEvRT_:
  108|  27.5k|  {
  109|  27.5k|    serialize_uint(*(typename boost::make_unsigned<T>::type *)&v);
  110|  27.5k|  }
_ZN14binary_archiveILb0EE14serialize_uintIjEEvRT_:
  118|  27.5k|  {
  119|  27.5k|    const std::size_t actual = bytes_.remove_prefix(sizeof(T));
  120|  27.5k|    good_ &= (actual == sizeof(T));
  121|  27.5k|    if (actual == sizeof(T))
  ------------------
  |  Branch (121:9): [True: 27.4k, False: 107]
  ------------------
  122|  27.4k|    {
  123|  27.4k|      std::memcpy(std::addressof(v), bytes_.data() - sizeof(T), sizeof(T));
  124|  27.4k|      boost::endian::little_to_native_inplace(v); // epee isn't templated
  125|  27.4k|    }
  126|    107|    else
  127|    107|      v = 0; // ensures initialization
  128|  27.5k|  }
_ZN14binary_archiveILb0EE9end_arrayEv:
  160|   221k|  void end_array() { }
_ZN19binary_archive_baseILb0EE13begin_variantEv:
   74|  50.5k|  void begin_variant() { }
_ZN14binary_archiveILb0EE16read_variant_tagERh:
  165|  50.5k|  void read_variant_tag(variant_tag_type &t) {
  166|  50.5k|    serialize_int(t);
  167|  50.5k|  }
_ZN19binary_archive_baseILb0EE11end_variantEv:
   75|  49.0k|  void end_variant() { }
_ZN19binary_archive_baseILb0EE10end_objectEv:
   73|   433k|  void end_object() { }
_ZNK14binary_archiveILb0EE3eofEv:
  103|  40.7k|  bool eof() const noexcept { return bytes_.empty(); }
_ZNK14binary_archiveILb0EE6getposEv:
  104|      3|  std::size_t getpos() const noexcept { return bytes_.begin() - begin_; }
_ZN14binary_archiveILb0EE11begin_arrayEv:
  158|      1|  void begin_array() { }
_ZN14binary_archiveILb1EEC2ERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEE:
  183|  5.92k|  explicit binary_archive(stream_type &s) : base_type(), stream_(s) { }
_ZNK14binary_archiveILb1EE4goodEv:
  185|   546k|  bool good() const { return stream_.good(); }
_ZNK14binary_archiveILb1EE6getposEv:
  188|      6|  std::streampos getpos() const { return stream_.tellp(); }
_ZN14binary_archiveILb1EE14serialize_blobEPvmPKc:
  205|   151k|  {
  206|   151k|    stream_.write((char *)buf, len);
  207|   151k|  }
_ZN14binary_archiveILb1EE11begin_arrayEm:
  222|  17.2k|  {
  223|  17.2k|    serialize_varint(s);
  224|  17.2k|  }
_ZN14binary_archiveILb1EE11begin_arrayEv:
  225|      2|  void begin_array() { }
_ZN14binary_archiveILb1EE13delimit_arrayEv:
  226|   251k|  void delimit_array() { }
_ZN14binary_archiveILb1EE9end_arrayEv:
  227|  17.2k|  void end_array() { }
_ZN14binary_archiveILb1EE17write_variant_tagEh:
  232|  1.96k|  void write_variant_tag(variant_tag_type t) {
  233|  1.96k|    serialize_int(t);
  234|  1.96k|  }
_ZN14binary_archiveILb1EE16serialize_varintImEEvRT_:
  211|  18.5k|  {
  212|  18.5k|    serialize_uvarint(*(typename boost::make_unsigned<T>::type *)(&v));
  213|  18.5k|  }
_ZN14binary_archiveILb1EE17serialize_uvarintImEEvRT_:
  217|  18.5k|  {
  218|  18.5k|    typedef std::ostreambuf_iterator<char> it;
  219|  18.5k|    tools::write_varint(it(stream_), v);
  220|  18.5k|  }
_ZN14binary_archiveILb1EE13serialize_intIhEEvT_:
  192|   109k|  {
  193|   109k|    serialize_uint(static_cast<typename boost::make_unsigned<T>::type>(v));
  194|   109k|  }
_ZN14binary_archiveILb1EE14serialize_uintIhEEvT_:
  197|   109k|  {
  198|   218k|    for (size_t i = 0; i < sizeof(T); i++) {
  ------------------
  |  Branch (198:24): [True: 109k, False: 109k]
  ------------------
  199|   109k|      stream_.put((char)(v & 0xff));
  200|       |      if constexpr (1 < sizeof(T)) { v >>= 8; }
  201|   109k|    }
  202|   109k|  }
_ZN19binary_archive_baseILb1EEC2Ev:
   68|  5.92k|  explicit binary_archive_base() { }
_ZN19binary_archive_baseILb1EE12begin_objectEv:
   72|  5.81k|  void begin_object() { }
_ZN19binary_archive_baseILb1EE3tagEPKc:
   71|  24.7k|  void tag(const char *) { }
_ZN19binary_archive_baseILb1EE10end_objectEv:
   73|  5.81k|  void end_object() { }
_ZN14binary_archiveILb1EE16serialize_varintIjEEvRT_:
  211|  5.59k|  {
  212|  5.59k|    serialize_uvarint(*(typename boost::make_unsigned<T>::type *)(&v));
  213|  5.59k|  }
_ZN14binary_archiveILb1EE17serialize_uvarintIjEEvRT_:
  217|  5.59k|  {
  218|  5.59k|    typedef std::ostreambuf_iterator<char> it;
  219|  5.59k|    tools::write_varint(it(stream_), v);
  220|  5.59k|  }
_ZN19binary_archive_baseILb1EE13begin_variantEv:
   74|  1.96k|  void begin_variant() { }
_ZN19binary_archive_baseILb1EE11end_variantEv:
   75|  1.96k|  void end_variant() { }
_ZN14binary_archiveILb1EE13serialize_intIjEEvT_:
  192|      3|  {
  193|      3|    serialize_uint(static_cast<typename boost::make_unsigned<T>::type>(v));
  194|      3|  }
_ZN14binary_archiveILb1EE14serialize_uintIjEEvT_:
  197|      3|  {
  198|     15|    for (size_t i = 0; i < sizeof(T); i++) {
  ------------------
  |  Branch (198:24): [True: 12, False: 3]
  ------------------
  199|     12|      stream_.put((char)(v & 0xff));
  200|     12|      if constexpr (1 < sizeof(T)) { v >>= 8; }
  201|     12|    }
  202|      3|  }
_ZN14binary_archiveILb1EE17serialize_uvarintIhEEvRT_:
  217|      6|  {
  218|      6|    typedef std::ostreambuf_iterator<char> it;
  219|      6|    tools::write_varint(it(stream_), v);
  220|      6|  }
_ZN14binary_archiveILb1EE16serialize_varintIhEEvRT_:
  211|      6|  {
  212|      6|    serialize_uvarint(*(typename boost::make_unsigned<T>::type *)(&v));
  213|      6|  }

_Z22do_serialize_containerI14binary_archiveNSt3__16vectorIN5tools7wallet220tx_construction_dataENS1_9allocatorIS5_EEEEEbRT_ILb0EERT0_:
   87|  9.72k|{
   88|  9.72k|  size_t cnt;
   89|  9.72k|  ar.begin_array(cnt);
   90|  9.72k|  if (!ar.good())
  ------------------
  |  Branch (90:7): [True: 9, False: 9.71k]
  ------------------
   91|      9|    return false;
   92|  9.71k|  v.clear();
   93|       |
   94|       |  // very basic sanity check
   95|  9.71k|  if (ar.remaining_bytes() < cnt) {
  ------------------
  |  Branch (95:7): [True: 133, False: 9.57k]
  ------------------
   96|    133|    ar.set_fail();
   97|    133|    return false;
   98|    133|  }
   99|       |
  100|  9.57k|  ::serialization::detail::do_reserve(v, cnt);
  101|       |
  102|  15.5k|  for (size_t i = 0; i < cnt; i++) {
  ------------------
  |  Branch (102:22): [True: 9.02k, False: 6.52k]
  ------------------
  103|  9.02k|    if (i > 0)
  ------------------
  |  Branch (103:9): [True: 5.42k, False: 3.60k]
  ------------------
  104|  5.42k|      ar.delimit_array();
  105|  9.02k|    typename ::serialization::detail::serializable_value_type<C>::type e;
  106|  9.02k|    if (!::serialization::detail::serialize_container_element(ar, e))
  ------------------
  |  Branch (106:9): [True: 3.05k, False: 5.96k]
  ------------------
  107|  3.05k|      return false;
  108|  5.96k|    ::serialization::detail::do_add(v, std::move(e));
  109|  5.96k|    if (!ar.good())
  ------------------
  |  Branch (109:9): [True: 0, False: 5.96k]
  ------------------
  110|      0|      return false;
  111|  5.96k|  }
  112|  6.52k|  ar.end_array();
  113|  6.52k|  return true;
  114|  9.57k|}
_ZN13serialization6detail10do_reserveINSt3__16vectorIN5tools7wallet220tx_construction_dataENS2_9allocatorIS6_EEEEEEDTcldtfp_7reservefp0_EERT_m:
   72|  9.57k|    auto do_reserve(C &c, std::size_t N) -> decltype(c.reserve(N)) { return c.reserve(N); }
_ZN13serialization6detail27serialize_container_elementI14binary_archiveILb0EEN5tools7wallet220tx_construction_dataEEENSt3__19enable_ifIXntcl20use_container_varintIT0_EEEbE4typeERT_RS9_:
   44|  9.02k|    {
   45|  9.02k|      return do_serialize(ar, e);
   46|  9.02k|    }
_Z22do_serialize_containerI14binary_archiveNSt3__16vectorIN10cryptonote15tx_source_entryENS1_9allocatorIS4_EEEEEbRT_ILb0EERT0_:
   87|  9.02k|{
   88|  9.02k|  size_t cnt;
   89|  9.02k|  ar.begin_array(cnt);
   90|  9.02k|  if (!ar.good())
  ------------------
  |  Branch (90:7): [True: 22, False: 9.00k]
  ------------------
   91|     22|    return false;
   92|  9.00k|  v.clear();
   93|       |
   94|       |  // very basic sanity check
   95|  9.00k|  if (ar.remaining_bytes() < cnt) {
  ------------------
  |  Branch (95:7): [True: 214, False: 8.78k]
  ------------------
   96|    214|    ar.set_fail();
   97|    214|    return false;
   98|    214|  }
   99|       |
  100|  8.78k|  ::serialization::detail::do_reserve(v, cnt);
  101|       |
  102|  11.1k|  for (size_t i = 0; i < cnt; i++) {
  ------------------
  |  Branch (102:22): [True: 3.11k, False: 8.04k]
  ------------------
  103|  3.11k|    if (i > 0)
  ------------------
  |  Branch (103:9): [True: 480, False: 2.63k]
  ------------------
  104|    480|      ar.delimit_array();
  105|  3.11k|    typename ::serialization::detail::serializable_value_type<C>::type e;
  106|  3.11k|    if (!::serialization::detail::serialize_container_element(ar, e))
  ------------------
  |  Branch (106:9): [True: 748, False: 2.36k]
  ------------------
  107|    748|      return false;
  108|  2.36k|    ::serialization::detail::do_add(v, std::move(e));
  109|  2.36k|    if (!ar.good())
  ------------------
  |  Branch (109:9): [True: 0, False: 2.36k]
  ------------------
  110|      0|      return false;
  111|  2.36k|  }
  112|  8.04k|  ar.end_array();
  113|  8.04k|  return true;
  114|  8.78k|}
_ZN13serialization6detail10do_reserveINSt3__16vectorIN10cryptonote15tx_source_entryENS2_9allocatorIS5_EEEEEEDTcldtfp_7reservefp0_EERT_m:
   72|  8.78k|    auto do_reserve(C &c, std::size_t N) -> decltype(c.reserve(N)) { return c.reserve(N); }
_ZN13serialization6detail27serialize_container_elementI14binary_archiveILb0EEN10cryptonote15tx_source_entryEEENSt3__19enable_ifIXntcl20use_container_varintIT0_EEEbE4typeERT_RS8_:
   44|  3.11k|    {
   45|  3.11k|      return do_serialize(ar, e);
   46|  3.11k|    }
_Z22do_serialize_containerI14binary_archiveNSt3__16vectorINS1_4pairImN3rct5ctkeyEEENS1_9allocatorIS6_EEEEEbRT_ILb0EERT0_:
   87|  3.11k|{
   88|  3.11k|  size_t cnt;
   89|  3.11k|  ar.begin_array(cnt);
   90|  3.11k|  if (!ar.good())
  ------------------
  |  Branch (90:7): [True: 5, False: 3.10k]
  ------------------
   91|      5|    return false;
   92|  3.10k|  v.clear();
   93|       |
   94|       |  // very basic sanity check
   95|  3.10k|  if (ar.remaining_bytes() < cnt) {
  ------------------
  |  Branch (95:7): [True: 140, False: 2.96k]
  ------------------
   96|    140|    ar.set_fail();
   97|    140|    return false;
   98|    140|  }
   99|       |
  100|  2.96k|  ::serialization::detail::do_reserve(v, cnt);
  101|       |
  102|  6.53k|  for (size_t i = 0; i < cnt; i++) {
  ------------------
  |  Branch (102:22): [True: 3.85k, False: 2.67k]
  ------------------
  103|  3.85k|    if (i > 0)
  ------------------
  |  Branch (103:9): [True: 1.18k, False: 2.67k]
  ------------------
  104|  1.18k|      ar.delimit_array();
  105|  3.85k|    typename ::serialization::detail::serializable_value_type<C>::type e;
  106|  3.85k|    if (!::serialization::detail::serialize_container_element(ar, e))
  ------------------
  |  Branch (106:9): [True: 291, False: 3.56k]
  ------------------
  107|    291|      return false;
  108|  3.56k|    ::serialization::detail::do_add(v, std::move(e));
  109|  3.56k|    if (!ar.good())
  ------------------
  |  Branch (109:9): [True: 0, False: 3.56k]
  ------------------
  110|      0|      return false;
  111|  3.56k|  }
  112|  2.67k|  ar.end_array();
  113|  2.67k|  return true;
  114|  2.96k|}
_ZN13serialization6detail10do_reserveINSt3__16vectorINS2_4pairImN3rct5ctkeyEEENS2_9allocatorIS7_EEEEEEDTcldtfp_7reservefp0_EERT_m:
   72|  2.96k|    auto do_reserve(C &c, std::size_t N) -> decltype(c.reserve(N)) { return c.reserve(N); }
_ZN13serialization6detail27serialize_container_elementI14binary_archiveILb0EENSt3__14pairImN3rct5ctkeyEEEEENS4_9enable_ifIXntcl20use_container_varintIT0_EEEbE4typeERT_RSA_:
   44|  3.85k|    {
   45|  3.85k|      return do_serialize(ar, e);
   46|  3.85k|    }
_ZN13serialization6detail6do_addINSt3__16vectorINS2_4pairImN3rct5ctkeyEEENS2_9allocatorIS7_EEEEEEDTcldtfp_12emplace_backfp0_EERT_ONSC_10value_typeE:
   63|  3.56k|    { return c.emplace_back(e); }
_Z22do_serialize_containerI14binary_archiveNSt3__16vectorIN6crypto10public_keyENS1_9allocatorIS4_EEEEEbRT_ILb0EERT0_:
   87|  61.2k|{
   88|  61.2k|  size_t cnt;
   89|  61.2k|  ar.begin_array(cnt);
   90|  61.2k|  if (!ar.good())
  ------------------
  |  Branch (90:7): [True: 126, False: 61.1k]
  ------------------
   91|    126|    return false;
   92|  61.1k|  v.clear();
   93|       |
   94|       |  // very basic sanity check
   95|  61.1k|  if (ar.remaining_bytes() < cnt) {
  ------------------
  |  Branch (95:7): [True: 154, False: 60.9k]
  ------------------
   96|    154|    ar.set_fail();
   97|    154|    return false;
   98|    154|  }
   99|       |
  100|  60.9k|  ::serialization::detail::do_reserve(v, cnt);
  101|       |
  102|   357k|  for (size_t i = 0; i < cnt; i++) {
  ------------------
  |  Branch (102:22): [True: 296k, False: 60.8k]
  ------------------
  103|   296k|    if (i > 0)
  ------------------
  |  Branch (103:9): [True: 252k, False: 43.4k]
  ------------------
  104|   252k|      ar.delimit_array();
  105|   296k|    typename ::serialization::detail::serializable_value_type<C>::type e;
  106|   296k|    if (!::serialization::detail::serialize_container_element(ar, e))
  ------------------
  |  Branch (106:9): [True: 0, False: 296k]
  ------------------
  107|      0|      return false;
  108|   296k|    ::serialization::detail::do_add(v, std::move(e));
  109|   296k|    if (!ar.good())
  ------------------
  |  Branch (109:9): [True: 97, False: 296k]
  ------------------
  110|     97|      return false;
  111|   296k|  }
  112|  60.8k|  ar.end_array();
  113|  60.8k|  return true;
  114|  60.9k|}
_ZN13serialization6detail10do_reserveINSt3__16vectorIN6crypto10public_keyENS2_9allocatorIS5_EEEEEEDTcldtfp_7reservefp0_EERT_m:
   72|  60.9k|    auto do_reserve(C &c, std::size_t N) -> decltype(c.reserve(N)) { return c.reserve(N); }
_ZN13serialization6detail27serialize_container_elementI14binary_archiveILb0EEN6crypto10public_keyEEENSt3__19enable_ifIXntcl20use_container_varintIT0_EEEbE4typeERT_RS8_:
   44|   296k|    {
   45|   296k|      return do_serialize(ar, e);
   46|   296k|    }
_ZN13serialization6detail6do_addINSt3__16vectorIN6crypto10public_keyENS2_9allocatorIS5_EEEEEEDTcldtfp_12emplace_backfp0_EERT_ONSA_10value_typeE:
   63|   296k|    { return c.emplace_back(e); }
_ZN13serialization6detail6do_addINSt3__16vectorIN10cryptonote15tx_source_entryENS2_9allocatorIS5_EEEEEEDTcldtfp_12emplace_backfp0_EERT_ONSA_10value_typeE:
   63|  2.36k|    { return c.emplace_back(e); }
_Z22do_serialize_containerI14binary_archiveNSt3__16vectorIN10cryptonote20tx_destination_entryENS1_9allocatorIS4_EEEEEbRT_ILb0EERT0_:
   87|  12.9k|{
   88|  12.9k|  size_t cnt;
   89|  12.9k|  ar.begin_array(cnt);
   90|  12.9k|  if (!ar.good())
  ------------------
  |  Branch (90:7): [True: 8, False: 12.9k]
  ------------------
   91|      8|    return false;
   92|  12.9k|  v.clear();
   93|       |
   94|       |  // very basic sanity check
   95|  12.9k|  if (ar.remaining_bytes() < cnt) {
  ------------------
  |  Branch (95:7): [True: 136, False: 12.8k]
  ------------------
   96|    136|    ar.set_fail();
   97|    136|    return false;
   98|    136|  }
   99|       |
  100|  12.8k|  ::serialization::detail::do_reserve(v, cnt);
  101|       |
  102|   118k|  for (size_t i = 0; i < cnt; i++) {
  ------------------
  |  Branch (102:22): [True: 106k, False: 12.6k]
  ------------------
  103|   106k|    if (i > 0)
  ------------------
  |  Branch (103:9): [True: 104k, False: 1.64k]
  ------------------
  104|   104k|      ar.delimit_array();
  105|   106k|    typename ::serialization::detail::serializable_value_type<C>::type e;
  106|   106k|    if (!::serialization::detail::serialize_container_element(ar, e))
  ------------------
  |  Branch (106:9): [True: 184, False: 106k]
  ------------------
  107|    184|      return false;
  108|   106k|    ::serialization::detail::do_add(v, std::move(e));
  109|   106k|    if (!ar.good())
  ------------------
  |  Branch (109:9): [True: 0, False: 106k]
  ------------------
  110|      0|      return false;
  111|   106k|  }
  112|  12.6k|  ar.end_array();
  113|  12.6k|  return true;
  114|  12.8k|}
_ZN13serialization6detail10do_reserveINSt3__16vectorIN10cryptonote20tx_destination_entryENS2_9allocatorIS5_EEEEEEDTcldtfp_7reservefp0_EERT_m:
   72|  12.8k|    auto do_reserve(C &c, std::size_t N) -> decltype(c.reserve(N)) { return c.reserve(N); }
_ZN13serialization6detail27serialize_container_elementI14binary_archiveILb0EEN10cryptonote20tx_destination_entryEEENSt3__19enable_ifIXntcl20use_container_varintIT0_EEEbE4typeERT_RS8_:
   44|   106k|    {
   45|   106k|      return do_serialize(ar, e);
   46|   106k|    }
_ZN13serialization6detail6do_addINSt3__16vectorIN10cryptonote20tx_destination_entryENS2_9allocatorIS5_EEEEEEDTcldtfp_12emplace_backfp0_EERT_ONSA_10value_typeE:
   63|   106k|    { return c.emplace_back(e); }
_Z22do_serialize_containerI14binary_archiveNSt3__16vectorImNS1_9allocatorImEEEEEbRT_ILb0EERT0_:
   87|  8.91k|{
   88|  8.91k|  size_t cnt;
   89|  8.91k|  ar.begin_array(cnt);
   90|  8.91k|  if (!ar.good())
  ------------------
  |  Branch (90:7): [True: 12, False: 8.89k]
  ------------------
   91|     12|    return false;
   92|  8.89k|  v.clear();
   93|       |
   94|       |  // very basic sanity check
   95|  8.89k|  if (ar.remaining_bytes() < cnt) {
  ------------------
  |  Branch (95:7): [True: 136, False: 8.76k]
  ------------------
   96|    136|    ar.set_fail();
   97|    136|    return false;
   98|    136|  }
   99|       |
  100|  8.76k|  ::serialization::detail::do_reserve(v, cnt);
  101|       |
  102|   130k|  for (size_t i = 0; i < cnt; i++) {
  ------------------
  |  Branch (102:22): [True: 122k, False: 8.74k]
  ------------------
  103|   122k|    if (i > 0)
  ------------------
  |  Branch (103:9): [True: 120k, False: 1.96k]
  ------------------
  104|   120k|      ar.delimit_array();
  105|   122k|    typename ::serialization::detail::serializable_value_type<C>::type e;
  106|   122k|    if (!::serialization::detail::serialize_container_element(ar, e))
  ------------------
  |  Branch (106:9): [True: 0, False: 122k]
  ------------------
  107|      0|      return false;
  108|   122k|    ::serialization::detail::do_add(v, std::move(e));
  109|   122k|    if (!ar.good())
  ------------------
  |  Branch (109:9): [True: 19, False: 122k]
  ------------------
  110|     19|      return false;
  111|   122k|  }
  112|  8.74k|  ar.end_array();
  113|  8.74k|  return true;
  114|  8.76k|}
_ZN13serialization6detail10do_reserveINSt3__16vectorImNS2_9allocatorImEEEEEEDTcldtfp_7reservefp0_EERT_m:
   72|  8.76k|    auto do_reserve(C &c, std::size_t N) -> decltype(c.reserve(N)) { return c.reserve(N); }
_ZN13serialization6detail27serialize_container_elementI14binary_archiveILb0EEmEENSt3__19enable_ifIXcl20use_container_varintIT0_EEEbE4typeERT_RS6_:
   51|   122k|    {
   52|   122k|      static constexpr const bool previously_varint = std::is_same<uint64_t, T>() || std::is_same<uint32_t, T>();
  ------------------
  |  Branch (52:55): [Folded - Ignored]
  |  Branch (52:86): [Folded - Ignored]
  ------------------
   53|       |
   54|   122k|      if (!previously_varint && ar.varint_bug_backward_compatibility_enabled() && !typename Archive::is_saving())
  ------------------
  |  Branch (54:11): [Folded - Ignored]
  |  Branch (54:11): [Folded - Ignored]
  |  Branch (54:33): [True: 0, False: 0]
  |  Branch (54:83): [Folded - Ignored]
  ------------------
   55|      0|        return do_serialize(ar, e);
   56|   122k|      ar.serialize_varint(e);
   57|   122k|      return true;
   58|   122k|    }
_ZN13serialization6detail6do_addINSt3__16vectorImNS2_9allocatorImEEEEEEDTcldtfp_12emplace_backfp0_EERT_ONS8_10value_typeE:
   63|   122k|    { return c.emplace_back(e); }
_Z22do_serialize_containerI14binary_archiveNSt3__16vectorIhNS1_9allocatorIhEEEEEbRT_ILb0EERT0_:
   87|  37.2k|{
   88|  37.2k|  size_t cnt;
   89|  37.2k|  ar.begin_array(cnt);
   90|  37.2k|  if (!ar.good())
  ------------------
  |  Branch (90:7): [True: 17, False: 37.1k]
  ------------------
   91|     17|    return false;
   92|  37.1k|  v.clear();
   93|       |
   94|       |  // very basic sanity check
   95|  37.1k|  if (ar.remaining_bytes() < cnt) {
  ------------------
  |  Branch (95:7): [True: 152, False: 37.0k]
  ------------------
   96|    152|    ar.set_fail();
   97|    152|    return false;
   98|    152|  }
   99|       |
  100|  37.0k|  ::serialization::detail::do_reserve(v, cnt);
  101|       |
  102|  3.10M|  for (size_t i = 0; i < cnt; i++) {
  ------------------
  |  Branch (102:22): [True: 3.06M, False: 37.0k]
  ------------------
  103|  3.06M|    if (i > 0)
  ------------------
  |  Branch (103:9): [True: 3.04M, False: 16.3k]
  ------------------
  104|  3.04M|      ar.delimit_array();
  105|  3.06M|    typename ::serialization::detail::serializable_value_type<C>::type e;
  106|  3.06M|    if (!::serialization::detail::serialize_container_element(ar, e))
  ------------------
  |  Branch (106:9): [True: 0, False: 3.06M]
  ------------------
  107|      0|      return false;
  108|  3.06M|    ::serialization::detail::do_add(v, std::move(e));
  109|  3.06M|    if (!ar.good())
  ------------------
  |  Branch (109:9): [True: 0, False: 3.06M]
  ------------------
  110|      0|      return false;
  111|  3.06M|  }
  112|  37.0k|  ar.end_array();
  113|  37.0k|  return true;
  114|  37.0k|}
_ZN13serialization6detail10do_reserveINSt3__16vectorIhNS2_9allocatorIhEEEEEEDTcldtfp_7reservefp0_EERT_m:
   72|  37.0k|    auto do_reserve(C &c, std::size_t N) -> decltype(c.reserve(N)) { return c.reserve(N); }
_ZN13serialization6detail27serialize_container_elementI14binary_archiveILb0EEhEENSt3__19enable_ifIXntcl20use_container_varintIT0_EEEbE4typeERT_RS6_:
   44|  3.06M|    {
   45|  3.06M|      return do_serialize(ar, e);
   46|  3.06M|    }
_ZN13serialization6detail6do_addINSt3__16vectorIhNS2_9allocatorIhEEEEEEDTcldtfp_12emplace_backfp0_EERT_ONS8_10value_typeE:
   63|  3.06M|    { return c.emplace_back(e); }
_Z22do_serialize_containerI14binary_archiveNSt3__13setIjNS1_4lessIjEENS1_9allocatorIjEEEEEbRT_ILb0EERT0_:
   87|  6.17k|{
   88|  6.17k|  size_t cnt;
   89|  6.17k|  ar.begin_array(cnt);
   90|  6.17k|  if (!ar.good())
  ------------------
  |  Branch (90:7): [True: 13, False: 6.16k]
  ------------------
   91|     13|    return false;
   92|  6.16k|  v.clear();
   93|       |
   94|       |  // very basic sanity check
   95|  6.16k|  if (ar.remaining_bytes() < cnt) {
  ------------------
  |  Branch (95:7): [True: 133, False: 6.02k]
  ------------------
   96|    133|    ar.set_fail();
   97|    133|    return false;
   98|    133|  }
   99|       |
  100|  6.02k|  ::serialization::detail::do_reserve(v, cnt);
  101|       |
  102|  57.5k|  for (size_t i = 0; i < cnt; i++) {
  ------------------
  |  Branch (102:22): [True: 51.5k, False: 5.96k]
  ------------------
  103|  51.5k|    if (i > 0)
  ------------------
  |  Branch (103:9): [True: 50.3k, False: 1.21k]
  ------------------
  104|  50.3k|      ar.delimit_array();
  105|  51.5k|    typename ::serialization::detail::serializable_value_type<C>::type e;
  106|  51.5k|    if (!::serialization::detail::serialize_container_element(ar, e))
  ------------------
  |  Branch (106:9): [True: 0, False: 51.5k]
  ------------------
  107|      0|      return false;
  108|  51.5k|    ::serialization::detail::do_add(v, std::move(e));
  109|  51.5k|    if (!ar.good())
  ------------------
  |  Branch (109:9): [True: 62, False: 51.4k]
  ------------------
  110|     62|      return false;
  111|  51.5k|  }
  112|  5.96k|  ar.end_array();
  113|  5.96k|  return true;
  114|  6.02k|}
_ZN13serialization6detail10do_reserveIJNSt3__13setIjNS2_4lessIjEENS2_9allocatorIjEEEEmEEEvDpRKT_:
   70|  6.02k|    void do_reserve(const C&...) {}
_ZN13serialization6detail27serialize_container_elementI14binary_archiveILb0EEjEENSt3__19enable_ifIXcl20use_container_varintIT0_EEEbE4typeERT_RS6_:
   51|  51.5k|    {
   52|  51.5k|      static constexpr const bool previously_varint = std::is_same<uint64_t, T>() || std::is_same<uint32_t, T>();
  ------------------
  |  Branch (52:55): [Folded - Ignored]
  |  Branch (52:86): [Folded - Ignored]
  ------------------
   53|       |
   54|  51.5k|      if (!previously_varint && ar.varint_bug_backward_compatibility_enabled() && !typename Archive::is_saving())
  ------------------
  |  Branch (54:11): [Folded - Ignored]
  |  Branch (54:11): [Folded - Ignored]
  |  Branch (54:33): [True: 0, False: 0]
  |  Branch (54:83): [Folded - Ignored]
  ------------------
   55|      0|        return do_serialize(ar, e);
   56|  51.5k|      ar.serialize_varint(e);
   57|  51.5k|      return true;
   58|  51.5k|    }
_ZN13serialization6detail6do_addINSt3__13setIjNS2_4lessIjEENS2_9allocatorIjEEEEEEDTcldtfp_7emplacefp0_EERT_ONSA_10value_typeE:
   66|  51.5k|    { return c.emplace(e); }
_ZN13serialization6detail6do_addINSt3__16vectorIN5tools7wallet220tx_construction_dataENS2_9allocatorIS6_EEEEEEDTcldtfp_12emplace_backfp0_EERT_ONSB_10value_typeE:
   63|  5.96k|    { return c.emplace_back(e); }
_Z22do_serialize_containerI14binary_archiveNSt3__16vectorIN5tools7wallet216transfer_detailsENS1_9allocatorIS5_EEEEEbRT_ILb0EERT0_:
   87|  3.95k|{
   88|  3.95k|  size_t cnt;
   89|  3.95k|  ar.begin_array(cnt);
   90|  3.95k|  if (!ar.good())
  ------------------
  |  Branch (90:7): [True: 7, False: 3.94k]
  ------------------
   91|      7|    return false;
   92|  3.94k|  v.clear();
   93|       |
   94|       |  // very basic sanity check
   95|  3.94k|  if (ar.remaining_bytes() < cnt) {
  ------------------
  |  Branch (95:7): [True: 122, False: 3.82k]
  ------------------
   96|    122|    ar.set_fail();
   97|    122|    return false;
   98|    122|  }
   99|       |
  100|  3.82k|  ::serialization::detail::do_reserve(v, cnt);
  101|       |
  102|  13.4k|  for (size_t i = 0; i < cnt; i++) {
  ------------------
  |  Branch (102:22): [True: 12.4k, False: 927]
  ------------------
  103|  12.4k|    if (i > 0)
  ------------------
  |  Branch (103:9): [True: 8.67k, False: 3.80k]
  ------------------
  104|  8.67k|      ar.delimit_array();
  105|  12.4k|    typename ::serialization::detail::serializable_value_type<C>::type e;
  106|  12.4k|    if (!::serialization::detail::serialize_container_element(ar, e))
  ------------------
  |  Branch (106:9): [True: 2.89k, False: 9.58k]
  ------------------
  107|  2.89k|      return false;
  108|  9.58k|    ::serialization::detail::do_add(v, std::move(e));
  109|  9.58k|    if (!ar.good())
  ------------------
  |  Branch (109:9): [True: 0, False: 9.58k]
  ------------------
  110|      0|      return false;
  111|  9.58k|  }
  112|    927|  ar.end_array();
  113|    927|  return true;
  114|  3.82k|}
_ZN13serialization6detail10do_reserveINSt3__16vectorIN5tools7wallet216transfer_detailsENS2_9allocatorIS6_EEEEEEDTcldtfp_7reservefp0_EERT_m:
   72|  3.82k|    auto do_reserve(C &c, std::size_t N) -> decltype(c.reserve(N)) { return c.reserve(N); }
_ZN13serialization6detail27serialize_container_elementI14binary_archiveILb0EEN5tools7wallet216transfer_detailsEEENSt3__19enable_ifIXntcl20use_container_varintIT0_EEEbE4typeERT_RS9_:
   44|  12.4k|    {
   45|  12.4k|      return do_serialize(ar, e);
   46|  12.4k|    }
_Z22do_serialize_containerI14binary_archiveNSt3__16vectorIN5boost7variantIN10cryptonote8txin_genEJNS5_14txin_to_scriptENS5_18txin_to_scripthashENS5_11txin_to_keyEEEENS1_9allocatorISA_EEEEEbRT_ILb0EERT0_:
   87|  12.1k|{
   88|  12.1k|  size_t cnt;
   89|  12.1k|  ar.begin_array(cnt);
   90|  12.1k|  if (!ar.good())
  ------------------
  |  Branch (90:7): [True: 5, False: 12.1k]
  ------------------
   91|      5|    return false;
   92|  12.1k|  v.clear();
   93|       |
   94|       |  // very basic sanity check
   95|  12.1k|  if (ar.remaining_bytes() < cnt) {
  ------------------
  |  Branch (95:7): [True: 120, False: 12.0k]
  ------------------
   96|    120|    ar.set_fail();
   97|    120|    return false;
   98|    120|  }
   99|       |
  100|  12.0k|  ::serialization::detail::do_reserve(v, cnt);
  101|       |
  102|  21.7k|  for (size_t i = 0; i < cnt; i++) {
  ------------------
  |  Branch (102:22): [True: 10.2k, False: 11.5k]
  ------------------
  103|  10.2k|    if (i > 0)
  ------------------
  |  Branch (103:9): [True: 7.64k, False: 2.59k]
  ------------------
  104|  7.64k|      ar.delimit_array();
  105|  10.2k|    typename ::serialization::detail::serializable_value_type<C>::type e;
  106|  10.2k|    if (!::serialization::detail::serialize_container_element(ar, e))
  ------------------
  |  Branch (106:9): [True: 537, False: 9.70k]
  ------------------
  107|    537|      return false;
  108|  9.70k|    ::serialization::detail::do_add(v, std::move(e));
  109|  9.70k|    if (!ar.good())
  ------------------
  |  Branch (109:9): [True: 0, False: 9.70k]
  ------------------
  110|      0|      return false;
  111|  9.70k|  }
  112|  11.5k|  ar.end_array();
  113|  11.5k|  return true;
  114|  12.0k|}
_ZN13serialization6detail10do_reserveINSt3__16vectorIN5boost7variantIN10cryptonote8txin_genEJNS6_14txin_to_scriptENS6_18txin_to_scripthashENS6_11txin_to_keyEEEENS2_9allocatorISB_EEEEEEDTcldtfp_7reservefp0_EERT_m:
   72|  12.0k|    auto do_reserve(C &c, std::size_t N) -> decltype(c.reserve(N)) { return c.reserve(N); }
_ZN13serialization6detail27serialize_container_elementI14binary_archiveILb0EEN5boost7variantIN10cryptonote8txin_genEJNS6_14txin_to_scriptENS6_18txin_to_scripthashENS6_11txin_to_keyEEEEEENSt3__19enable_ifIXntcl20use_container_varintIT0_EEEbE4typeERT_RSE_:
   44|  10.2k|    {
   45|  10.2k|      return do_serialize(ar, e);
   46|  10.2k|    }
_ZN13serialization6detail6do_addINSt3__16vectorIN5boost7variantIN10cryptonote8txin_genEJNS6_14txin_to_scriptENS6_18txin_to_scripthashENS6_11txin_to_keyEEEENS2_9allocatorISB_EEEEEEDTcldtfp_12emplace_backfp0_EERT_ONSG_10value_typeE:
   63|  9.70k|    { return c.emplace_back(e); }
_Z22do_serialize_containerI14binary_archiveNSt3__16vectorIN10cryptonote6tx_outENS1_9allocatorIS4_EEEEEbRT_ILb0EERT0_:
   87|  11.5k|{
   88|  11.5k|  size_t cnt;
   89|  11.5k|  ar.begin_array(cnt);
   90|  11.5k|  if (!ar.good())
  ------------------
  |  Branch (90:7): [True: 7, False: 11.5k]
  ------------------
   91|      7|    return false;
   92|  11.5k|  v.clear();
   93|       |
   94|       |  // very basic sanity check
   95|  11.5k|  if (ar.remaining_bytes() < cnt) {
  ------------------
  |  Branch (95:7): [True: 117, False: 11.4k]
  ------------------
   96|    117|    ar.set_fail();
   97|    117|    return false;
   98|    117|  }
   99|       |
  100|  11.4k|  ::serialization::detail::do_reserve(v, cnt);
  101|       |
  102|  29.4k|  for (size_t i = 0; i < cnt; i++) {
  ------------------
  |  Branch (102:22): [True: 18.4k, False: 11.0k]
  ------------------
  103|  18.4k|    if (i > 0)
  ------------------
  |  Branch (103:9): [True: 15.6k, False: 2.75k]
  ------------------
  104|  15.6k|      ar.delimit_array();
  105|  18.4k|    typename ::serialization::detail::serializable_value_type<C>::type e;
  106|  18.4k|    if (!::serialization::detail::serialize_container_element(ar, e))
  ------------------
  |  Branch (106:9): [True: 388, False: 18.0k]
  ------------------
  107|    388|      return false;
  108|  18.0k|    ::serialization::detail::do_add(v, std::move(e));
  109|  18.0k|    if (!ar.good())
  ------------------
  |  Branch (109:9): [True: 0, False: 18.0k]
  ------------------
  110|      0|      return false;
  111|  18.0k|  }
  112|  11.0k|  ar.end_array();
  113|  11.0k|  return true;
  114|  11.4k|}
_ZN13serialization6detail10do_reserveINSt3__16vectorIN10cryptonote6tx_outENS2_9allocatorIS5_EEEEEEDTcldtfp_7reservefp0_EERT_m:
   72|  11.4k|    auto do_reserve(C &c, std::size_t N) -> decltype(c.reserve(N)) { return c.reserve(N); }
_ZN13serialization6detail27serialize_container_elementI14binary_archiveILb0EEN10cryptonote6tx_outEEENSt3__19enable_ifIXntcl20use_container_varintIT0_EEEbE4typeERT_RS8_:
   44|  18.4k|    {
   45|  18.4k|      return do_serialize(ar, e);
   46|  18.4k|    }
_ZN13serialization6detail6do_addINSt3__16vectorIN10cryptonote6tx_outENS2_9allocatorIS5_EEEEEEDTcldtfp_12emplace_backfp0_EERT_ONSA_10value_typeE:
   63|  18.0k|    { return c.emplace_back(e); }
_Z22do_serialize_containerI14binary_archiveNSt3__16vectorIN3rct3keyENS1_9allocatorIS4_EEEEEbRT_ILb0EERT0_:
   87|  10.6k|{
   88|  10.6k|  size_t cnt;
   89|  10.6k|  ar.begin_array(cnt);
   90|  10.6k|  if (!ar.good())
  ------------------
  |  Branch (90:7): [True: 4, False: 10.6k]
  ------------------
   91|      4|    return false;
   92|  10.6k|  v.clear();
   93|       |
   94|       |  // very basic sanity check
   95|  10.6k|  if (ar.remaining_bytes() < cnt) {
  ------------------
  |  Branch (95:7): [True: 117, False: 10.4k]
  ------------------
   96|    117|    ar.set_fail();
   97|    117|    return false;
   98|    117|  }
   99|       |
  100|  10.4k|  ::serialization::detail::do_reserve(v, cnt);
  101|       |
  102|  48.7k|  for (size_t i = 0; i < cnt; i++) {
  ------------------
  |  Branch (102:22): [True: 38.2k, False: 10.4k]
  ------------------
  103|  38.2k|    if (i > 0)
  ------------------
  |  Branch (103:9): [True: 36.4k, False: 1.82k]
  ------------------
  104|  36.4k|      ar.delimit_array();
  105|  38.2k|    typename ::serialization::detail::serializable_value_type<C>::type e;
  106|  38.2k|    if (!::serialization::detail::serialize_container_element(ar, e))
  ------------------
  |  Branch (106:9): [True: 0, False: 38.2k]
  ------------------
  107|      0|      return false;
  108|  38.2k|    ::serialization::detail::do_add(v, std::move(e));
  109|  38.2k|    if (!ar.good())
  ------------------
  |  Branch (109:9): [True: 36, False: 38.2k]
  ------------------
  110|     36|      return false;
  111|  38.2k|  }
  112|  10.4k|  ar.end_array();
  113|  10.4k|  return true;
  114|  10.4k|}
_ZN13serialization6detail10do_reserveINSt3__16vectorIN3rct3keyENS2_9allocatorIS5_EEEEEEDTcldtfp_7reservefp0_EERT_m:
   72|  10.4k|    auto do_reserve(C &c, std::size_t N) -> decltype(c.reserve(N)) { return c.reserve(N); }
_ZN13serialization6detail27serialize_container_elementI14binary_archiveILb0EEN3rct3keyEEENSt3__19enable_ifIXntcl20use_container_varintIT0_EEEbE4typeERT_RS8_:
   44|  38.2k|    {
   45|  38.2k|      return do_serialize(ar, e);
   46|  38.2k|    }
_ZN13serialization6detail6do_addINSt3__16vectorIN3rct3keyENS2_9allocatorIS5_EEEEEEDTcldtfp_12emplace_backfp0_EERT_ONSA_10value_typeE:
   63|  38.2k|    { return c.emplace_back(e); }
_Z22do_serialize_containerI14binary_archiveNSt3__16vectorIN5tools7wallet213multisig_infoENS1_9allocatorIS5_EEEEEbRT_ILb0EERT0_:
   87|  10.4k|{
   88|  10.4k|  size_t cnt;
   89|  10.4k|  ar.begin_array(cnt);
   90|  10.4k|  if (!ar.good())
  ------------------
  |  Branch (90:7): [True: 3, False: 10.4k]
  ------------------
   91|      3|    return false;
   92|  10.4k|  v.clear();
   93|       |
   94|       |  // very basic sanity check
   95|  10.4k|  if (ar.remaining_bytes() < cnt) {
  ------------------
  |  Branch (95:7): [True: 118, False: 10.3k]
  ------------------
   96|    118|    ar.set_fail();
   97|    118|    return false;
   98|    118|  }
   99|       |
  100|  10.3k|  ::serialization::detail::do_reserve(v, cnt);
  101|       |
  102|  18.7k|  for (size_t i = 0; i < cnt; i++) {
  ------------------
  |  Branch (102:22): [True: 8.84k, False: 9.95k]
  ------------------
  103|  8.84k|    if (i > 0)
  ------------------
  |  Branch (103:9): [True: 7.06k, False: 1.77k]
  ------------------
  104|  7.06k|      ar.delimit_array();
  105|  8.84k|    typename ::serialization::detail::serializable_value_type<C>::type e;
  106|  8.84k|    if (!::serialization::detail::serialize_container_element(ar, e))
  ------------------
  |  Branch (106:9): [True: 370, False: 8.47k]
  ------------------
  107|    370|      return false;
  108|  8.47k|    ::serialization::detail::do_add(v, std::move(e));
  109|  8.47k|    if (!ar.good())
  ------------------
  |  Branch (109:9): [True: 0, False: 8.47k]
  ------------------
  110|      0|      return false;
  111|  8.47k|  }
  112|  9.95k|  ar.end_array();
  113|  9.95k|  return true;
  114|  10.3k|}
_ZN13serialization6detail10do_reserveINSt3__16vectorIN5tools7wallet213multisig_infoENS2_9allocatorIS6_EEEEEEDTcldtfp_7reservefp0_EERT_m:
   72|  10.3k|    auto do_reserve(C &c, std::size_t N) -> decltype(c.reserve(N)) { return c.reserve(N); }
_ZN13serialization6detail27serialize_container_elementI14binary_archiveILb0EEN5tools7wallet213multisig_infoEEENSt3__19enable_ifIXntcl20use_container_varintIT0_EEEbE4typeERT_RS9_:
   44|  8.84k|    {
   45|  8.84k|      return do_serialize(ar, e);
   46|  8.84k|    }
_Z22do_serialize_containerI14binary_archiveNSt3__16vectorIN5tools7wallet213multisig_info2LRENS1_9allocatorIS6_EEEEEbRT_ILb0EERT0_:
   87|  8.77k|{
   88|  8.77k|  size_t cnt;
   89|  8.77k|  ar.begin_array(cnt);
   90|  8.77k|  if (!ar.good())
  ------------------
  |  Branch (90:7): [True: 16, False: 8.75k]
  ------------------
   91|     16|    return false;
   92|  8.75k|  v.clear();
   93|       |
   94|       |  // very basic sanity check
   95|  8.75k|  if (ar.remaining_bytes() < cnt) {
  ------------------
  |  Branch (95:7): [True: 25, False: 8.73k]
  ------------------
   96|     25|    ar.set_fail();
   97|     25|    return false;
   98|     25|  }
   99|       |
  100|  8.73k|  ::serialization::detail::do_reserve(v, cnt);
  101|       |
  102|  66.4k|  for (size_t i = 0; i < cnt; i++) {
  ------------------
  |  Branch (102:22): [True: 57.8k, False: 8.65k]
  ------------------
  103|  57.8k|    if (i > 0)
  ------------------
  |  Branch (103:9): [True: 55.2k, False: 2.63k]
  ------------------
  104|  55.2k|      ar.delimit_array();
  105|  57.8k|    typename ::serialization::detail::serializable_value_type<C>::type e;
  106|  57.8k|    if (!::serialization::detail::serialize_container_element(ar, e))
  ------------------
  |  Branch (106:9): [True: 76, False: 57.7k]
  ------------------
  107|     76|      return false;
  108|  57.7k|    ::serialization::detail::do_add(v, std::move(e));
  109|  57.7k|    if (!ar.good())
  ------------------
  |  Branch (109:9): [True: 0, False: 57.7k]
  ------------------
  110|      0|      return false;
  111|  57.7k|  }
  112|  8.65k|  ar.end_array();
  113|  8.65k|  return true;
  114|  8.73k|}
_ZN13serialization6detail10do_reserveINSt3__16vectorIN5tools7wallet213multisig_info2LRENS2_9allocatorIS7_EEEEEEDTcldtfp_7reservefp0_EERT_m:
   72|  8.73k|    auto do_reserve(C &c, std::size_t N) -> decltype(c.reserve(N)) { return c.reserve(N); }
_ZN13serialization6detail27serialize_container_elementI14binary_archiveILb0EEN5tools7wallet213multisig_info2LREEENSt3__19enable_ifIXntcl20use_container_varintIT0_EEEbE4typeERT_RSA_:
   44|  57.8k|    {
   45|  57.8k|      return do_serialize(ar, e);
   46|  57.8k|    }
_ZN13serialization6detail6do_addINSt3__16vectorIN5tools7wallet213multisig_info2LRENS2_9allocatorIS7_EEEEEEDTcldtfp_12emplace_backfp0_EERT_ONSC_10value_typeE:
   63|  57.7k|    { return c.emplace_back(e); }
_Z22do_serialize_containerI14binary_archiveNSt3__16vectorIN6crypto9key_imageENS1_9allocatorIS4_EEEEEbRT_ILb0EERT0_:
   87|  8.65k|{
   88|  8.65k|  size_t cnt;
   89|  8.65k|  ar.begin_array(cnt);
   90|  8.65k|  if (!ar.good())
  ------------------
  |  Branch (90:7): [True: 6, False: 8.65k]
  ------------------
   91|      6|    return false;
   92|  8.65k|  v.clear();
   93|       |
   94|       |  // very basic sanity check
   95|  8.65k|  if (ar.remaining_bytes() < cnt) {
  ------------------
  |  Branch (95:7): [True: 123, False: 8.52k]
  ------------------
   96|    123|    ar.set_fail();
   97|    123|    return false;
   98|    123|  }
   99|       |
  100|  8.52k|  ::serialization::detail::do_reserve(v, cnt);
  101|       |
  102|   117k|  for (size_t i = 0; i < cnt; i++) {
  ------------------
  |  Branch (102:22): [True: 109k, False: 8.47k]
  ------------------
  103|   109k|    if (i > 0)
  ------------------
  |  Branch (103:9): [True: 107k, False: 2.33k]
  ------------------
  104|   107k|      ar.delimit_array();
  105|   109k|    typename ::serialization::detail::serializable_value_type<C>::type e;
  106|   109k|    if (!::serialization::detail::serialize_container_element(ar, e))
  ------------------
  |  Branch (106:9): [True: 0, False: 109k]
  ------------------
  107|      0|      return false;
  108|   109k|    ::serialization::detail::do_add(v, std::move(e));
  109|   109k|    if (!ar.good())
  ------------------
  |  Branch (109:9): [True: 58, False: 109k]
  ------------------
  110|     58|      return false;
  111|   109k|  }
  112|  8.47k|  ar.end_array();
  113|  8.47k|  return true;
  114|  8.52k|}
_ZN13serialization6detail10do_reserveINSt3__16vectorIN6crypto9key_imageENS2_9allocatorIS5_EEEEEEDTcldtfp_7reservefp0_EERT_m:
   72|  8.52k|    auto do_reserve(C &c, std::size_t N) -> decltype(c.reserve(N)) { return c.reserve(N); }
_ZN13serialization6detail27serialize_container_elementI14binary_archiveILb0EEN6crypto9key_imageEEENSt3__19enable_ifIXntcl20use_container_varintIT0_EEEbE4typeERT_RS8_:
   44|   109k|    {
   45|   109k|      return do_serialize(ar, e);
   46|   109k|    }
_ZN13serialization6detail6do_addINSt3__16vectorIN6crypto9key_imageENS2_9allocatorIS5_EEEEEEDTcldtfp_12emplace_backfp0_EERT_ONSA_10value_typeE:
   63|   109k|    { return c.emplace_back(e); }
_ZN13serialization6detail6do_addINSt3__16vectorIN5tools7wallet213multisig_infoENS2_9allocatorIS6_EEEEEEDTcldtfp_12emplace_backfp0_EERT_ONSB_10value_typeE:
   63|  8.47k|    { return c.emplace_back(e); }
_Z22do_serialize_containerI14binary_archiveNSt3__16vectorINS1_4pairImN6crypto4hashEEENS1_9allocatorIS6_EEEEEbRT_ILb0EERT0_:
   87|  9.95k|{
   88|  9.95k|  size_t cnt;
   89|  9.95k|  ar.begin_array(cnt);
   90|  9.95k|  if (!ar.good())
  ------------------
  |  Branch (90:7): [True: 7, False: 9.94k]
  ------------------
   91|      7|    return false;
   92|  9.94k|  v.clear();
   93|       |
   94|       |  // very basic sanity check
   95|  9.94k|  if (ar.remaining_bytes() < cnt) {
  ------------------
  |  Branch (95:7): [True: 124, False: 9.82k]
  ------------------
   96|    124|    ar.set_fail();
   97|    124|    return false;
   98|    124|  }
   99|       |
  100|  9.82k|  ::serialization::detail::do_reserve(v, cnt);
  101|       |
  102|  12.1k|  for (size_t i = 0; i < cnt; i++) {
  ------------------
  |  Branch (102:22): [True: 2.52k, False: 9.58k]
  ------------------
  103|  2.52k|    if (i > 0)
  ------------------
  |  Branch (103:9): [True: 1.05k, False: 1.47k]
  ------------------
  104|  1.05k|      ar.delimit_array();
  105|  2.52k|    typename ::serialization::detail::serializable_value_type<C>::type e;
  106|  2.52k|    if (!::serialization::detail::serialize_container_element(ar, e))
  ------------------
  |  Branch (106:9): [True: 240, False: 2.28k]
  ------------------
  107|    240|      return false;
  108|  2.28k|    ::serialization::detail::do_add(v, std::move(e));
  109|  2.28k|    if (!ar.good())
  ------------------
  |  Branch (109:9): [True: 0, False: 2.28k]
  ------------------
  110|      0|      return false;
  111|  2.28k|  }
  112|  9.58k|  ar.end_array();
  113|  9.58k|  return true;
  114|  9.82k|}
_ZN13serialization6detail10do_reserveINSt3__16vectorINS2_4pairImN6crypto4hashEEENS2_9allocatorIS7_EEEEEEDTcldtfp_7reservefp0_EERT_m:
   72|  9.82k|    auto do_reserve(C &c, std::size_t N) -> decltype(c.reserve(N)) { return c.reserve(N); }
_ZN13serialization6detail27serialize_container_elementI14binary_archiveILb0EENSt3__14pairImN6crypto4hashEEEEENS4_9enable_ifIXntcl20use_container_varintIT0_EEEbE4typeERT_RSA_:
   44|  2.52k|    {
   45|  2.52k|      return do_serialize(ar, e);
   46|  2.52k|    }
_ZN13serialization6detail6do_addINSt3__16vectorINS2_4pairImN6crypto4hashEEENS2_9allocatorIS7_EEEEEEDTcldtfp_12emplace_backfp0_EERT_ONSC_10value_typeE:
   63|  2.28k|    { return c.emplace_back(e); }
_ZN13serialization6detail6do_addINSt3__16vectorIN5tools7wallet216transfer_detailsENS2_9allocatorIS6_EEEEEEDTcldtfp_12emplace_backfp0_EERT_ONSB_10value_typeE:
   63|  9.58k|    { return c.emplace_back(e); }
_Z22do_serialize_containerI14binary_archiveNSt3__16vectorIN5tools7wallet225exported_transfer_detailsENS1_9allocatorIS5_EEEEEbRT_ILb0EERT0_:
   87|  1.59k|{
   88|  1.59k|  size_t cnt;
   89|  1.59k|  ar.begin_array(cnt);
   90|  1.59k|  if (!ar.good())
  ------------------
  |  Branch (90:7): [True: 8, False: 1.59k]
  ------------------
   91|      8|    return false;
   92|  1.59k|  v.clear();
   93|       |
   94|       |  // very basic sanity check
   95|  1.59k|  if (ar.remaining_bytes() < cnt) {
  ------------------
  |  Branch (95:7): [True: 123, False: 1.46k]
  ------------------
   96|    123|    ar.set_fail();
   97|    123|    return false;
   98|    123|  }
   99|       |
  100|  1.46k|  ::serialization::detail::do_reserve(v, cnt);
  101|       |
  102|  45.0k|  for (size_t i = 0; i < cnt; i++) {
  ------------------
  |  Branch (102:22): [True: 44.1k, False: 936]
  ------------------
  103|  44.1k|    if (i > 0)
  ------------------
  |  Branch (103:9): [True: 42.7k, False: 1.41k]
  ------------------
  104|  42.7k|      ar.delimit_array();
  105|  44.1k|    typename ::serialization::detail::serializable_value_type<C>::type e;
  106|  44.1k|    if (!::serialization::detail::serialize_container_element(ar, e))
  ------------------
  |  Branch (106:9): [True: 532, False: 43.6k]
  ------------------
  107|    532|      return false;
  108|  43.6k|    ::serialization::detail::do_add(v, std::move(e));
  109|  43.6k|    if (!ar.good())
  ------------------
  |  Branch (109:9): [True: 0, False: 43.6k]
  ------------------
  110|      0|      return false;
  111|  43.6k|  }
  112|    936|  ar.end_array();
  113|    936|  return true;
  114|  1.46k|}
_ZN13serialization6detail10do_reserveINSt3__16vectorIN5tools7wallet225exported_transfer_detailsENS2_9allocatorIS6_EEEEEEDTcldtfp_7reservefp0_EERT_m:
   72|  1.46k|    auto do_reserve(C &c, std::size_t N) -> decltype(c.reserve(N)) { return c.reserve(N); }
_ZN13serialization6detail27serialize_container_elementI14binary_archiveILb0EEN5tools7wallet225exported_transfer_detailsEEENSt3__19enable_ifIXntcl20use_container_varintIT0_EEEbE4typeERT_RS9_:
   44|  44.1k|    {
   45|  44.1k|      return do_serialize(ar, e);
   46|  44.1k|    }
_ZN13serialization6detail6do_addINSt3__16vectorIN5tools7wallet225exported_transfer_detailsENS2_9allocatorIS6_EEEEEEDTcldtfp_12emplace_backfp0_EERT_ONSB_10value_typeE:
   63|  43.6k|    { return c.emplace_back(e); }
_Z22do_serialize_containerI14binary_archiveNSt3__16vectorIN6crypto10public_keyENS1_9allocatorIS4_EEEEEbRT_ILb1EERT0_:
  118|    309|{
  119|    309|  size_t cnt = v.size();
  120|    309|  ar.begin_array(cnt);
  121|   115k|  for (auto i = v.begin(); i != v.end(); ++i)
  ------------------
  |  Branch (121:28): [True: 114k, False: 309]
  ------------------
  122|   114k|  {
  123|   114k|    if (!ar.good())
  ------------------
  |  Branch (123:9): [True: 0, False: 114k]
  ------------------
  124|      0|      return false;
  125|   114k|    if (i != v.begin())
  ------------------
  |  Branch (125:9): [True: 114k, False: 234]
  ------------------
  126|   114k|      ar.delimit_array();
  127|   114k|    using serializable_value_type = typename ::serialization::detail::serializable_value_type<C>::type;
  128|   114k|    if(!::serialization::detail::serialize_container_element(ar, (serializable_value_type&)*i))
  ------------------
  |  Branch (128:8): [True: 0, False: 114k]
  ------------------
  129|      0|      return false;
  130|   114k|    if (!ar.good())
  ------------------
  |  Branch (130:9): [True: 0, False: 114k]
  ------------------
  131|      0|      return false;
  132|   114k|  }
  133|    309|  ar.end_array();
  134|    309|  return true;
  135|    309|}
_ZN13serialization6detail27serialize_container_elementI14binary_archiveILb1EEN6crypto10public_keyEEENSt3__19enable_ifIXntcl20use_container_varintIT0_EEEbE4typeERT_RS8_:
   44|   114k|    {
   45|   114k|      return do_serialize(ar, e);
   46|   114k|    }
_Z22do_serialize_containerI14binary_archiveNSt3__16vectorIN5boost7variantIN10cryptonote8txin_genEJNS5_14txin_to_scriptENS5_18txin_to_scripthashENS5_11txin_to_keyEEEENS1_9allocatorISA_EEEEEbRT_ILb1EERT0_:
  118|     24|{
  119|     24|  size_t cnt = v.size();
  120|     24|  ar.begin_array(cnt);
  121|    116|  for (auto i = v.begin(); i != v.end(); ++i)
  ------------------
  |  Branch (121:28): [True: 92, False: 24]
  ------------------
  122|     92|  {
  123|     92|    if (!ar.good())
  ------------------
  |  Branch (123:9): [True: 0, False: 92]
  ------------------
  124|      0|      return false;
  125|     92|    if (i != v.begin())
  ------------------
  |  Branch (125:9): [True: 88, False: 4]
  ------------------
  126|     88|      ar.delimit_array();
  127|     92|    using serializable_value_type = typename ::serialization::detail::serializable_value_type<C>::type;
  128|     92|    if(!::serialization::detail::serialize_container_element(ar, (serializable_value_type&)*i))
  ------------------
  |  Branch (128:8): [True: 0, False: 92]
  ------------------
  129|      0|      return false;
  130|     92|    if (!ar.good())
  ------------------
  |  Branch (130:9): [True: 0, False: 92]
  ------------------
  131|      0|      return false;
  132|     92|  }
  133|     24|  ar.end_array();
  134|     24|  return true;
  135|     24|}
_ZN13serialization6detail27serialize_container_elementI14binary_archiveILb1EEN5boost7variantIN10cryptonote8txin_genEJNS6_14txin_to_scriptENS6_18txin_to_scripthashENS6_11txin_to_keyEEEEEENSt3__19enable_ifIXntcl20use_container_varintIT0_EEEbE4typeERT_RSE_:
   44|     92|    {
   45|     92|      return do_serialize(ar, e);
   46|     92|    }
_Z22do_serialize_containerI14binary_archiveNSt3__16vectorImNS1_9allocatorImEEEEEbRT_ILb1EERT0_:
  118|     24|{
  119|     24|  size_t cnt = v.size();
  120|     24|  ar.begin_array(cnt);
  121|     32|  for (auto i = v.begin(); i != v.end(); ++i)
  ------------------
  |  Branch (121:28): [True: 8, False: 24]
  ------------------
  122|      8|  {
  123|      8|    if (!ar.good())
  ------------------
  |  Branch (123:9): [True: 0, False: 8]
  ------------------
  124|      0|      return false;
  125|      8|    if (i != v.begin())
  ------------------
  |  Branch (125:9): [True: 6, False: 2]
  ------------------
  126|      6|      ar.delimit_array();
  127|      8|    using serializable_value_type = typename ::serialization::detail::serializable_value_type<C>::type;
  128|      8|    if(!::serialization::detail::serialize_container_element(ar, (serializable_value_type&)*i))
  ------------------
  |  Branch (128:8): [True: 0, False: 8]
  ------------------
  129|      0|      return false;
  130|      8|    if (!ar.good())
  ------------------
  |  Branch (130:9): [True: 0, False: 8]
  ------------------
  131|      0|      return false;
  132|      8|  }
  133|     24|  ar.end_array();
  134|     24|  return true;
  135|     24|}
_ZN13serialization6detail27serialize_container_elementI14binary_archiveILb1EEmEENSt3__19enable_ifIXcl20use_container_varintIT0_EEEbE4typeERT_RS6_:
   51|      8|    {
   52|      8|      static constexpr const bool previously_varint = std::is_same<uint64_t, T>() || std::is_same<uint32_t, T>();
  ------------------
  |  Branch (52:55): [Folded - Ignored]
  |  Branch (52:86): [Folded - Ignored]
  ------------------
   53|       |
   54|      8|      if (!previously_varint && ar.varint_bug_backward_compatibility_enabled() && !typename Archive::is_saving())
  ------------------
  |  Branch (54:11): [Folded - Ignored]
  |  Branch (54:11): [Folded - Ignored]
  |  Branch (54:33): [True: 0, False: 0]
  |  Branch (54:83): [Folded - Ignored]
  ------------------
   55|      0|        return do_serialize(ar, e);
   56|      8|      ar.serialize_varint(e);
   57|      8|      return true;
   58|      8|    }
_Z22do_serialize_containerI14binary_archiveNSt3__16vectorIN10cryptonote6tx_outENS1_9allocatorIS4_EEEEEbRT_ILb1EERT0_:
  118|     24|{
  119|     24|  size_t cnt = v.size();
  120|     24|  ar.begin_array(cnt);
  121|     95|  for (auto i = v.begin(); i != v.end(); ++i)
  ------------------
  |  Branch (121:28): [True: 71, False: 24]
  ------------------
  122|     71|  {
  123|     71|    if (!ar.good())
  ------------------
  |  Branch (123:9): [True: 0, False: 71]
  ------------------
  124|      0|      return false;
  125|     71|    if (i != v.begin())
  ------------------
  |  Branch (125:9): [True: 51, False: 20]
  ------------------
  126|     51|      ar.delimit_array();
  127|     71|    using serializable_value_type = typename ::serialization::detail::serializable_value_type<C>::type;
  128|     71|    if(!::serialization::detail::serialize_container_element(ar, (serializable_value_type&)*i))
  ------------------
  |  Branch (128:8): [True: 0, False: 71]
  ------------------
  129|      0|      return false;
  130|     71|    if (!ar.good())
  ------------------
  |  Branch (130:9): [True: 0, False: 71]
  ------------------
  131|      0|      return false;
  132|     71|  }
  133|     24|  ar.end_array();
  134|     24|  return true;
  135|     24|}
_ZN13serialization6detail27serialize_container_elementI14binary_archiveILb1EEN10cryptonote6tx_outEEENSt3__19enable_ifIXntcl20use_container_varintIT0_EEEbE4typeERT_RS8_:
   44|     71|    {
   45|     71|      return do_serialize(ar, e);
   46|     71|    }
_Z22do_serialize_containerI14binary_archiveNSt3__16vectorIhNS1_9allocatorIhEEEEEbRT_ILb1EERT0_:
  118|    117|{
  119|    117|  size_t cnt = v.size();
  120|    117|  ar.begin_array(cnt);
  121|   104k|  for (auto i = v.begin(); i != v.end(); ++i)
  ------------------
  |  Branch (121:28): [True: 103k, False: 117]
  ------------------
  122|   103k|  {
  123|   103k|    if (!ar.good())
  ------------------
  |  Branch (123:9): [True: 0, False: 103k]
  ------------------
  124|      0|      return false;
  125|   103k|    if (i != v.begin())
  ------------------
  |  Branch (125:9): [True: 103k, False: 30]
  ------------------
  126|   103k|      ar.delimit_array();
  127|   103k|    using serializable_value_type = typename ::serialization::detail::serializable_value_type<C>::type;
  128|   103k|    if(!::serialization::detail::serialize_container_element(ar, (serializable_value_type&)*i))
  ------------------
  |  Branch (128:8): [True: 0, False: 103k]
  ------------------
  129|      0|      return false;
  130|   103k|    if (!ar.good())
  ------------------
  |  Branch (130:9): [True: 0, False: 103k]
  ------------------
  131|      0|      return false;
  132|   103k|  }
  133|    117|  ar.end_array();
  134|    117|  return true;
  135|    117|}
_ZN13serialization6detail27serialize_container_elementI14binary_archiveILb1EEhEENSt3__19enable_ifIXntcl20use_container_varintIT0_EEEbE4typeERT_RS6_:
   44|   103k|    {
   45|   103k|      return do_serialize(ar, e);
   46|   103k|    }
_Z22do_serialize_containerI14binary_archiveNSt3__16vectorIN6crypto9key_imageENS1_9allocatorIS4_EEEEEbRT_ILb1EERT0_:
  118|  5.59k|{
  119|  5.59k|  size_t cnt = v.size();
  120|  5.59k|  ar.begin_array(cnt);
  121|  40.9k|  for (auto i = v.begin(); i != v.end(); ++i)
  ------------------
  |  Branch (121:28): [True: 35.3k, False: 5.59k]
  ------------------
  122|  35.3k|  {
  123|  35.3k|    if (!ar.good())
  ------------------
  |  Branch (123:9): [True: 0, False: 35.3k]
  ------------------
  124|      0|      return false;
  125|  35.3k|    if (i != v.begin())
  ------------------
  |  Branch (125:9): [True: 32.5k, False: 2.77k]
  ------------------
  126|  32.5k|      ar.delimit_array();
  127|  35.3k|    using serializable_value_type = typename ::serialization::detail::serializable_value_type<C>::type;
  128|  35.3k|    if(!::serialization::detail::serialize_container_element(ar, (serializable_value_type&)*i))
  ------------------
  |  Branch (128:8): [True: 0, False: 35.3k]
  ------------------
  129|      0|      return false;
  130|  35.3k|    if (!ar.good())
  ------------------
  |  Branch (130:9): [True: 0, False: 35.3k]
  ------------------
  131|      0|      return false;
  132|  35.3k|  }
  133|  5.59k|  ar.end_array();
  134|  5.59k|  return true;
  135|  5.59k|}
_ZN13serialization6detail27serialize_container_elementI14binary_archiveILb1EEN6crypto9key_imageEEENSt3__19enable_ifIXntcl20use_container_varintIT0_EEEbE4typeERT_RS8_:
   44|  35.3k|    {
   45|  35.3k|      return do_serialize(ar, e);
   46|  35.3k|    }
_Z22do_serialize_containerI14binary_archiveNSt3__113unordered_mapIN6crypto10public_keyENS3_9key_imageENS1_4hashIS4_EENS1_8equal_toIS4_EENS1_9allocatorINS1_4pairIKS4_S5_EEEEEEEbRT_ILb1EERT0_:
  118|  5.59k|{
  119|  5.59k|  size_t cnt = v.size();
  120|  5.59k|  ar.begin_array(cnt);
  121|  5.59k|  for (auto i = v.begin(); i != v.end(); ++i)
  ------------------
  |  Branch (121:28): [True: 0, False: 5.59k]
  ------------------
  122|      0|  {
  123|      0|    if (!ar.good())
  ------------------
  |  Branch (123:9): [True: 0, False: 0]
  ------------------
  124|      0|      return false;
  125|      0|    if (i != v.begin())
  ------------------
  |  Branch (125:9): [True: 0, False: 0]
  ------------------
  126|      0|      ar.delimit_array();
  127|      0|    using serializable_value_type = typename ::serialization::detail::serializable_value_type<C>::type;
  128|      0|    if(!::serialization::detail::serialize_container_element(ar, (serializable_value_type&)*i))
  ------------------
  |  Branch (128:8): [True: 0, False: 0]
  ------------------
  129|      0|      return false;
  130|      0|    if (!ar.good())
  ------------------
  |  Branch (130:9): [True: 0, False: 0]
  ------------------
  131|      0|      return false;
  132|      0|  }
  133|  5.59k|  ar.end_array();
  134|  5.59k|  return true;
  135|  5.59k|}
_Z22do_serialize_containerI14binary_archiveNSt3__16vectorIN5tools7wallet210pending_txENS1_9allocatorIS5_EEEEEbRT_ILb1EERT0_:
  118|  5.59k|{
  119|  5.59k|  size_t cnt = v.size();
  120|  5.59k|  ar.begin_array(cnt);
  121|  5.59k|  for (auto i = v.begin(); i != v.end(); ++i)
  ------------------
  |  Branch (121:28): [True: 0, False: 5.59k]
  ------------------
  122|      0|  {
  123|      0|    if (!ar.good())
  ------------------
  |  Branch (123:9): [True: 0, False: 0]
  ------------------
  124|      0|      return false;
  125|      0|    if (i != v.begin())
  ------------------
  |  Branch (125:9): [True: 0, False: 0]
  ------------------
  126|      0|      ar.delimit_array();
  127|      0|    using serializable_value_type = typename ::serialization::detail::serializable_value_type<C>::type;
  128|      0|    if(!::serialization::detail::serialize_container_element(ar, (serializable_value_type&)*i))
  ------------------
  |  Branch (128:8): [True: 0, False: 0]
  ------------------
  129|      0|      return false;
  130|      0|    if (!ar.good())
  ------------------
  |  Branch (130:9): [True: 0, False: 0]
  ------------------
  131|      0|      return false;
  132|      0|  }
  133|  5.59k|  ar.end_array();
  134|  5.59k|  return true;
  135|  5.59k|}
_Z22do_serialize_containerI14binary_archiveNSt3__16vectorIN6crypto4hashENS1_9allocatorIS4_EEEEEbRT_ILb1EERT0_:
  118|      1|{
  119|      1|  size_t cnt = v.size();
  120|      1|  ar.begin_array(cnt);
  121|      1|  for (auto i = v.begin(); i != v.end(); ++i)
  ------------------
  |  Branch (121:28): [True: 0, False: 1]
  ------------------
  122|      0|  {
  123|      0|    if (!ar.good())
  ------------------
  |  Branch (123:9): [True: 0, False: 0]
  ------------------
  124|      0|      return false;
  125|      0|    if (i != v.begin())
  ------------------
  |  Branch (125:9): [True: 0, False: 0]
  ------------------
  126|      0|      ar.delimit_array();
  127|      0|    using serializable_value_type = typename ::serialization::detail::serializable_value_type<C>::type;
  128|      0|    if(!::serialization::detail::serialize_container_element(ar, (serializable_value_type&)*i))
  ------------------
  |  Branch (128:8): [True: 0, False: 0]
  ------------------
  129|      0|      return false;
  130|      0|    if (!ar.good())
  ------------------
  |  Branch (130:9): [True: 0, False: 0]
  ------------------
  131|      0|      return false;
  132|      0|  }
  133|      1|  ar.end_array();
  134|      1|  return true;
  135|      1|}

_Z12do_serializeI14binary_archiveILb0EENSt3__16vectorIN5tools7wallet220tx_construction_dataENS2_9allocatorIS6_EEEEENS2_9enable_ifIXgssr13serialization12is_containerIT0_EE5valueEbE4typeERT_RSB_:
   61|  9.72k|{
   62|  9.72k|    return ::do_serialize_container(ar, c);
   63|  9.72k|}
_Z12do_serializeI14binary_archiveILb0EENSt3__16vectorIN10cryptonote15tx_source_entryENS2_9allocatorIS5_EEEEENS2_9enable_ifIXgssr13serialization12is_containerIT0_EE5valueEbE4typeERT_RSA_:
   61|  9.02k|{
   62|  9.02k|    return ::do_serialize_container(ar, c);
   63|  9.02k|}
_Z12do_serializeI14binary_archiveILb0EENSt3__16vectorINS2_4pairImN3rct5ctkeyEEENS2_9allocatorIS7_EEEEENS2_9enable_ifIXgssr13serialization12is_containerIT0_EE5valueEbE4typeERT_RSC_:
   61|  3.11k|{
   62|  3.11k|    return ::do_serialize_container(ar, c);
   63|  3.11k|}
_Z12do_serializeI14binary_archiveILb0EENSt3__16vectorIN6crypto10public_keyENS2_9allocatorIS5_EEEEENS2_9enable_ifIXgssr13serialization12is_containerIT0_EE5valueEbE4typeERT_RSA_:
   61|  61.2k|{
   62|  61.2k|    return ::do_serialize_container(ar, c);
   63|  61.2k|}
_Z12do_serializeI14binary_archiveILb0EENSt3__16vectorIN10cryptonote20tx_destination_entryENS2_9allocatorIS5_EEEEENS2_9enable_ifIXgssr13serialization12is_containerIT0_EE5valueEbE4typeERT_RSA_:
   61|  12.9k|{
   62|  12.9k|    return ::do_serialize_container(ar, c);
   63|  12.9k|}
_Z12do_serializeI14binary_archiveILb0EENSt3__16vectorImNS2_9allocatorImEEEEENS2_9enable_ifIXgssr13serialization12is_containerIT0_EE5valueEbE4typeERT_RS8_:
   61|  8.91k|{
   62|  8.91k|    return ::do_serialize_container(ar, c);
   63|  8.91k|}
_Z12do_serializeI14binary_archiveILb0EENSt3__16vectorIhNS2_9allocatorIhEEEEENS2_9enable_ifIXgssr13serialization12is_containerIT0_EE5valueEbE4typeERT_RS8_:
   61|  37.2k|{
   62|  37.2k|    return ::do_serialize_container(ar, c);
   63|  37.2k|}
_Z12do_serializeI14binary_archiveILb0EENSt3__13setIjNS2_4lessIjEENS2_9allocatorIjEEEEENS2_9enable_ifIXgssr13serialization12is_containerIT0_EE5valueEbE4typeERT_RSA_:
   61|  6.17k|{
   62|  6.17k|    return ::do_serialize_container(ar, c);
   63|  6.17k|}
_Z12do_serializeI14binary_archiveILb0EENSt3__16vectorIN5tools7wallet216transfer_detailsENS2_9allocatorIS6_EEEEENS2_9enable_ifIXgssr13serialization12is_containerIT0_EE5valueEbE4typeERT_RSB_:
   61|  3.95k|{
   62|  3.95k|    return ::do_serialize_container(ar, c);
   63|  3.95k|}
_Z12do_serializeI14binary_archiveILb0EENSt3__16vectorIN5boost7variantIN10cryptonote8txin_genEJNS6_14txin_to_scriptENS6_18txin_to_scripthashENS6_11txin_to_keyEEEENS2_9allocatorISB_EEEEENS2_9enable_ifIXgssr13serialization12is_containerIT0_EE5valueEbE4typeERT_RSG_:
   61|  12.1k|{
   62|  12.1k|    return ::do_serialize_container(ar, c);
   63|  12.1k|}
_Z12do_serializeI14binary_archiveILb0EENSt3__16vectorIN10cryptonote6tx_outENS2_9allocatorIS5_EEEEENS2_9enable_ifIXgssr13serialization12is_containerIT0_EE5valueEbE4typeERT_RSA_:
   61|  11.5k|{
   62|  11.5k|    return ::do_serialize_container(ar, c);
   63|  11.5k|}
_Z12do_serializeI14binary_archiveILb0EENSt3__16vectorIN3rct3keyENS2_9allocatorIS5_EEEEENS2_9enable_ifIXgssr13serialization12is_containerIT0_EE5valueEbE4typeERT_RSA_:
   61|  10.6k|{
   62|  10.6k|    return ::do_serialize_container(ar, c);
   63|  10.6k|}
_Z12do_serializeI14binary_archiveILb0EENSt3__16vectorIN5tools7wallet213multisig_infoENS2_9allocatorIS6_EEEEENS2_9enable_ifIXgssr13serialization12is_containerIT0_EE5valueEbE4typeERT_RSB_:
   61|  10.4k|{
   62|  10.4k|    return ::do_serialize_container(ar, c);
   63|  10.4k|}
_Z12do_serializeI14binary_archiveILb0EENSt3__16vectorIN5tools7wallet213multisig_info2LRENS2_9allocatorIS7_EEEEENS2_9enable_ifIXgssr13serialization12is_containerIT0_EE5valueEbE4typeERT_RSC_:
   61|  8.77k|{
   62|  8.77k|    return ::do_serialize_container(ar, c);
   63|  8.77k|}
_Z12do_serializeI14binary_archiveILb0EENSt3__16vectorIN6crypto9key_imageENS2_9allocatorIS5_EEEEENS2_9enable_ifIXgssr13serialization12is_containerIT0_EE5valueEbE4typeERT_RSA_:
   61|  8.65k|{
   62|  8.65k|    return ::do_serialize_container(ar, c);
   63|  8.65k|}
_Z12do_serializeI14binary_archiveILb0EENSt3__16vectorINS2_4pairImN6crypto4hashEEENS2_9allocatorIS7_EEEEENS2_9enable_ifIXgssr13serialization12is_containerIT0_EE5valueEbE4typeERT_RSC_:
   61|  9.95k|{
   62|  9.95k|    return ::do_serialize_container(ar, c);
   63|  9.95k|}
_Z12do_serializeI14binary_archiveILb0EENSt3__16vectorIN5tools7wallet225exported_transfer_detailsENS2_9allocatorIS6_EEEEENS2_9enable_ifIXgssr13serialization12is_containerIT0_EE5valueEbE4typeERT_RSB_:
   61|  1.59k|{
   62|  1.59k|    return ::do_serialize_container(ar, c);
   63|  1.59k|}
_Z12do_serializeI14binary_archiveILb1EENSt3__16vectorIN6crypto10public_keyENS2_9allocatorIS5_EEEEENS2_9enable_ifIXgssr13serialization12is_containerIT0_EE5valueEbE4typeERT_RSA_:
   61|    309|{
   62|    309|    return ::do_serialize_container(ar, c);
   63|    309|}
_Z12do_serializeI14binary_archiveILb1EENSt3__16vectorIN5boost7variantIN10cryptonote8txin_genEJNS6_14txin_to_scriptENS6_18txin_to_scripthashENS6_11txin_to_keyEEEENS2_9allocatorISB_EEEEENS2_9enable_ifIXgssr13serialization12is_containerIT0_EE5valueEbE4typeERT_RSG_:
   61|     24|{
   62|     24|    return ::do_serialize_container(ar, c);
   63|     24|}
_Z12do_serializeI14binary_archiveILb1EENSt3__16vectorImNS2_9allocatorImEEEEENS2_9enable_ifIXgssr13serialization12is_containerIT0_EE5valueEbE4typeERT_RS8_:
   61|     24|{
   62|     24|    return ::do_serialize_container(ar, c);
   63|     24|}
_Z12do_serializeI14binary_archiveILb1EENSt3__16vectorIN10cryptonote6tx_outENS2_9allocatorIS5_EEEEENS2_9enable_ifIXgssr13serialization12is_containerIT0_EE5valueEbE4typeERT_RSA_:
   61|     24|{
   62|     24|    return ::do_serialize_container(ar, c);
   63|     24|}
_Z12do_serializeI14binary_archiveILb1EENSt3__16vectorIhNS2_9allocatorIhEEEEENS2_9enable_ifIXgssr13serialization12is_containerIT0_EE5valueEbE4typeERT_RS8_:
   61|    117|{
   62|    117|    return ::do_serialize_container(ar, c);
   63|    117|}
_Z12do_serializeI14binary_archiveILb1EENSt3__16vectorIN6crypto9key_imageENS2_9allocatorIS5_EEEEENS2_9enable_ifIXgssr13serialization12is_containerIT0_EE5valueEbE4typeERT_RSA_:
   61|  5.59k|{
   62|  5.59k|    return ::do_serialize_container(ar, c);
   63|  5.59k|}
_Z12do_serializeI14binary_archiveILb1EENSt3__113unordered_mapIN6crypto10public_keyENS4_9key_imageENS2_4hashIS5_EENS2_8equal_toIS5_EENS2_9allocatorINS2_4pairIKS5_S6_EEEEEEENS2_9enable_ifIXgssr13serialization12is_containerIT0_EE5valueEbE4typeERT_RSI_:
   61|  5.59k|{
   62|  5.59k|    return ::do_serialize_container(ar, c);
   63|  5.59k|}
_Z12do_serializeI14binary_archiveILb1EENSt3__16vectorIN5tools7wallet210pending_txENS2_9allocatorIS6_EEEEENS2_9enable_ifIXgssr13serialization12is_containerIT0_EE5valueEbE4typeERT_RSB_:
   61|  5.59k|{
   62|  5.59k|    return ::do_serialize_container(ar, c);
   63|  5.59k|}
_Z12do_serializeI14binary_archiveILb1EENSt3__16vectorIN6crypto4hashENS2_9allocatorIS5_EEEEENS2_9enable_ifIXgssr13serialization12is_containerIT0_EE5valueEbE4typeERT_RSA_:
   61|      1|{
   62|      1|    return ::do_serialize_container(ar, c);
   63|      1|}

_Z12do_serializeI14binary_archiveEbRT_ILb1EERNSt3__16vectorIN6crypto9signatureENS4_9allocatorIS7_EEEE:
   67|      2|{
   68|      2|  if (0 == v.size()) return true;
  ------------------
  |  Branch (68:7): [True: 2, False: 0]
  ------------------
   69|      0|  ar.begin_string();
   70|      0|  size_t cnt = v.size();
   71|      0|  for (size_t i = 0; i < cnt; i++) {
  ------------------
  |  Branch (71:22): [True: 0, False: 0]
  ------------------
   72|      0|    ar.serialize_blob(&(v[i]), sizeof(crypto::signature), "");
   73|      0|    if (!ar.good())
  ------------------
  |  Branch (73:9): [True: 0, False: 0]
  ------------------
   74|      0|      return false;
   75|      0|  }
   76|      0|  ar.end_string();
   77|      0|  return true;
   78|      0|}
_Z12do_serializeI14binary_archiveEbRT_ILb0EERNSt3__16vectorIN6crypto9signatureENS4_9allocatorIS7_EEEE:
   44|      1|{
   45|      1|  size_t cnt = v.size();
   46|      1|  v.clear();
   47|       |
   48|       |  // very basic sanity check
   49|      1|  if (ar.remaining_bytes() < cnt*sizeof(crypto::signature)) {
  ------------------
  |  Branch (49:7): [True: 0, False: 1]
  ------------------
   50|      0|    ar.set_fail();
   51|      0|    return false;
   52|      0|  }
   53|       |
   54|      1|  v.reserve(cnt);
   55|      1|  for (size_t i = 0; i < cnt; i++) {
  ------------------
  |  Branch (55:22): [True: 0, False: 1]
  ------------------
   56|      0|    v.resize(i+1);
   57|      0|    ar.serialize_blob(&(v[i]), sizeof(crypto::signature), "");
   58|      0|    if (!ar.good())
  ------------------
  |  Branch (58:9): [True: 0, False: 0]
  ------------------
   59|      0|      return false;
   60|      0|  }
   61|      1|  return true;
   62|      1|}

_Z12do_serializeI14binary_archivemN3rct5ctkeyEEbRT_ILb0EERNSt3__14pairIT0_T1_EE:
   69|  3.85k|{
   70|  3.85k|  size_t cnt;
   71|  3.85k|  ar.begin_array(cnt);
   72|  3.85k|  if (!ar.good())
  ------------------
  |  Branch (72:7): [True: 12, False: 3.84k]
  ------------------
   73|     12|    return false;
   74|  3.84k|  if (cnt != 2)
  ------------------
  |  Branch (74:7): [True: 211, False: 3.63k]
  ------------------
   75|    211|    return false;
   76|       |
   77|  3.63k|  if (!::serialization::detail::serialize_pair_element(ar, p.first))
  ------------------
  |  Branch (77:7): [True: 0, False: 3.63k]
  ------------------
   78|      0|    return false;
   79|  3.63k|  if (!ar.good())
  ------------------
  |  Branch (79:7): [True: 5, False: 3.63k]
  ------------------
   80|      5|    return false;
   81|  3.63k|  ar.delimit_array();
   82|  3.63k|  if (!::serialization::detail::serialize_pair_element(ar, p.second))
  ------------------
  |  Branch (82:7): [True: 0, False: 3.63k]
  ------------------
   83|      0|    return false;
   84|  3.63k|  if (!ar.good())
  ------------------
  |  Branch (84:7): [True: 63, False: 3.56k]
  ------------------
   85|     63|    return false;
   86|       |
   87|  3.56k|  ar.end_array();
   88|  3.56k|  return true;
   89|  3.63k|}
_ZN13serialization6detail22serialize_pair_elementI14binary_archiveILb0EEmEENSt3__19enable_ifIXcl15use_pair_varintIT0_EEEbE4typeERT_RS6_:
   56|  11.1k|    {
   57|  11.1k|      static constexpr const bool previously_varint = std::is_same<uint64_t, T>();
   58|       |
   59|  11.1k|      if (!previously_varint && ar.varint_bug_backward_compatibility_enabled() && !typename Archive::is_saving())
  ------------------
  |  Branch (59:11): [Folded - Ignored]
  |  Branch (59:11): [Folded - Ignored]
  |  Branch (59:33): [True: 0, False: 0]
  |  Branch (59:83): [Folded - Ignored]
  ------------------
   60|      0|        return do_serialize(ar, e);
   61|  11.1k|      ar.serialize_varint(e);
   62|  11.1k|      return true;
   63|  11.1k|    }
_ZN13serialization6detail22serialize_pair_elementI14binary_archiveILb0EEN3rct5ctkeyEEENSt3__19enable_ifIXntcl15use_pair_varintIT0_EEEbE4typeERT_RS8_:
   49|  3.63k|    {
   50|  3.63k|      return do_serialize(ar, e);
   51|  3.63k|    }
_Z12do_serializeI14binary_archivemNSt3__16vectorIN5tools7wallet216transfer_detailsENS1_9allocatorIS5_EEEEEbRT_ILb0EERNS1_4pairIT0_T1_EE:
   69|  4.01k|{
   70|  4.01k|  size_t cnt;
   71|  4.01k|  ar.begin_array(cnt);
   72|  4.01k|  if (!ar.good())
  ------------------
  |  Branch (72:7): [True: 9, False: 4.00k]
  ------------------
   73|      9|    return false;
   74|  4.00k|  if (cnt != 2)
  ------------------
  |  Branch (74:7): [True: 40, False: 3.96k]
  ------------------
   75|     40|    return false;
   76|       |
   77|  3.96k|  if (!::serialization::detail::serialize_pair_element(ar, p.first))
  ------------------
  |  Branch (77:7): [True: 0, False: 3.96k]
  ------------------
   78|      0|    return false;
   79|  3.96k|  if (!ar.good())
  ------------------
  |  Branch (79:7): [True: 8, False: 3.95k]
  ------------------
   80|      8|    return false;
   81|  3.95k|  ar.delimit_array();
   82|  3.95k|  if (!::serialization::detail::serialize_pair_element(ar, p.second))
  ------------------
  |  Branch (82:7): [True: 3.02k, False: 927]
  ------------------
   83|  3.02k|    return false;
   84|    927|  if (!ar.good())
  ------------------
  |  Branch (84:7): [True: 0, False: 927]
  ------------------
   85|      0|    return false;
   86|       |
   87|    927|  ar.end_array();
   88|    927|  return true;
   89|    927|}
_ZN13serialization6detail22serialize_pair_elementI14binary_archiveILb0EENSt3__16vectorIN5tools7wallet216transfer_detailsENS4_9allocatorIS8_EEEEEENS4_9enable_ifIXntcl15use_pair_varintIT0_EEEbE4typeERT_RSD_:
   49|  3.95k|    {
   50|  3.95k|      return do_serialize(ar, e);
   51|  3.95k|    }
_Z12do_serializeI14binary_archivemN6crypto4hashEEbRT_ILb0EERNSt3__14pairIT0_T1_EE:
   69|  2.52k|{
   70|  2.52k|  size_t cnt;
   71|  2.52k|  ar.begin_array(cnt);
   72|  2.52k|  if (!ar.good())
  ------------------
  |  Branch (72:7): [True: 4, False: 2.52k]
  ------------------
   73|      4|    return false;
   74|  2.52k|  if (cnt != 2)
  ------------------
  |  Branch (74:7): [True: 189, False: 2.33k]
  ------------------
   75|    189|    return false;
   76|       |
   77|  2.33k|  if (!::serialization::detail::serialize_pair_element(ar, p.first))
  ------------------
  |  Branch (77:7): [True: 0, False: 2.33k]
  ------------------
   78|      0|    return false;
   79|  2.33k|  if (!ar.good())
  ------------------
  |  Branch (79:7): [True: 5, False: 2.32k]
  ------------------
   80|      5|    return false;
   81|  2.32k|  ar.delimit_array();
   82|  2.32k|  if (!::serialization::detail::serialize_pair_element(ar, p.second))
  ------------------
  |  Branch (82:7): [True: 0, False: 2.32k]
  ------------------
   83|      0|    return false;
   84|  2.32k|  if (!ar.good())
  ------------------
  |  Branch (84:7): [True: 42, False: 2.28k]
  ------------------
   85|     42|    return false;
   86|       |
   87|  2.28k|  ar.end_array();
   88|  2.28k|  return true;
   89|  2.32k|}
_ZN13serialization6detail22serialize_pair_elementI14binary_archiveILb0EEN6crypto4hashEEENSt3__19enable_ifIXntcl15use_pair_varintIT0_EEEbE4typeERT_RS8_:
   49|  2.32k|    {
   50|  2.32k|      return do_serialize(ar, e);
   51|  2.32k|    }
_Z12do_serializeI14binary_archivemNSt3__16vectorIN5tools7wallet225exported_transfer_detailsENS1_9allocatorIS5_EEEEEbRT_ILb0EERNS1_4pairIT0_T1_EE:
   69|  1.38k|{
   70|  1.38k|  size_t cnt;
   71|  1.38k|  ar.begin_array(cnt);
   72|  1.38k|  if (!ar.good())
  ------------------
  |  Branch (72:7): [True: 8, False: 1.37k]
  ------------------
   73|      8|    return false;
   74|  1.37k|  if (cnt != 2)
  ------------------
  |  Branch (74:7): [True: 129, False: 1.24k]
  ------------------
   75|    129|    return false;
   76|       |
   77|  1.24k|  if (!::serialization::detail::serialize_pair_element(ar, p.first))
  ------------------
  |  Branch (77:7): [True: 0, False: 1.24k]
  ------------------
   78|      0|    return false;
   79|  1.24k|  if (!ar.good())
  ------------------
  |  Branch (79:7): [True: 6, False: 1.23k]
  ------------------
   80|      6|    return false;
   81|  1.23k|  ar.delimit_array();
   82|  1.23k|  if (!::serialization::detail::serialize_pair_element(ar, p.second))
  ------------------
  |  Branch (82:7): [True: 365, False: 873]
  ------------------
   83|    365|    return false;
   84|    873|  if (!ar.good())
  ------------------
  |  Branch (84:7): [True: 0, False: 873]
  ------------------
   85|      0|    return false;
   86|       |
   87|    873|  ar.end_array();
   88|    873|  return true;
   89|    873|}
_ZN13serialization6detail22serialize_pair_elementI14binary_archiveILb0EENSt3__16vectorIN5tools7wallet225exported_transfer_detailsENS4_9allocatorIS8_EEEEEENS4_9enable_ifIXntcl15use_pair_varintIT0_EEEbE4typeERT_RSD_:
   49|  1.23k|    {
   50|  1.23k|      return do_serialize(ar, e);
   51|  1.23k|    }

_ZN13serialization9serializeI14binary_archiveILb0EEN5tools7wallet215unsigned_tx_setEEEbRT_RT0_:
  363|  9.74k|  {
  364|  9.74k|    bool r = do_serialize(ar, v);
  365|  9.74k|    return r && check_stream_state(ar, false);
  ------------------
  |  Branch (365:12): [True: 1.86k, False: 7.88k]
  |  Branch (365:17): [True: 1.56k, False: 301]
  ------------------
  366|  9.74k|  }
_Z12do_serializeI14binary_archiveILb0EEN5tools7wallet215unsigned_tx_setEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|  9.74k|{
   90|  9.74k|  return v.member_do_serialize(ar);
   91|  9.74k|}
_ZN5tools7wallet215unsigned_tx_set19member_do_serializeILb0E14binary_archiveEEbRT0_IXT_EE:
  177|  9.74k|  bool member_do_serialize(Archive<W> &ar) {					\
  178|  9.74k|    ar.begin_object();							\
  179|  9.74k|    bool r = do_serialize_object(ar);					\
  180|  9.74k|    ar.end_object();							\
  181|  9.74k|    return r;								\
  182|  9.74k|  }									\
_Z12do_serializeI14binary_archiveILb0EEN5tools7wallet220tx_construction_dataEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|  9.02k|{
   90|  9.02k|  return v.member_do_serialize(ar);
   91|  9.02k|}
_ZN5tools7wallet220tx_construction_data19member_do_serializeILb0E14binary_archiveEEbRT0_IXT_EE:
  177|  9.02k|  bool member_do_serialize(Archive<W> &ar) {					\
  178|  9.02k|    ar.begin_object();							\
  179|  9.02k|    bool r = do_serialize_object(ar);					\
  180|  9.02k|    ar.end_object();							\
  181|  9.02k|    return r;								\
  182|  9.02k|  }									\
_Z12do_serializeI14binary_archiveILb0EEN10cryptonote15tx_source_entryEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|  3.11k|{
   90|  3.11k|  return v.member_do_serialize(ar);
   91|  3.11k|}
_ZN10cryptonote15tx_source_entry19member_do_serializeILb0E14binary_archiveEEbRT0_IXT_EE:
  177|  3.11k|  bool member_do_serialize(Archive<W> &ar) {					\
  178|  3.11k|    ar.begin_object();							\
  179|  3.11k|    bool r = do_serialize_object(ar);					\
  180|  3.11k|    ar.end_object();							\
  181|  3.11k|    return r;								\
  182|  3.11k|  }									\
_Z12do_serializeI14binary_archiveILb0EEN3rct5ctkeyEENSt3__19enable_ifIXsr12is_blob_typeIT0_E4typeE5valueEbE4typeERT_RS6_:
   75|  3.63k|{
   76|  3.63k|  static_assert(std::is_trivially_copyable<T>() || is_blob_forced<T>(),
   77|  3.63k|    "sanity check: types that can't be trivially copied shouldn't be using the blob serializer");
   78|  3.63k|  ar.serialize_blob(&v, sizeof(v));
   79|  3.63k|  return true;
   80|  3.63k|}
_Z12do_serializeI14binary_archiveILb0EEN6crypto10public_keyEENSt3__19enable_ifIXsr12is_blob_typeIT0_E4typeE5valueEbE4typeERT_RS6_:
   75|   627k|{
   76|   627k|  static_assert(std::is_trivially_copyable<T>() || is_blob_forced<T>(),
   77|   627k|    "sanity check: types that can't be trivially copied shouldn't be using the blob serializer");
   78|   627k|  ar.serialize_blob(&v, sizeof(v));
   79|   627k|  return true;
   80|   627k|}
_Z12do_serializeI14binary_archiveILb0EEEbRT_Rb:
   94|   292k|{
   95|   292k|  ar.serialize_blob(&v, sizeof(v));
   96|   292k|  return true;
   97|   292k|}
_Z12do_serializeI14binary_archiveILb0EEN3rct3keyEENSt3__19enable_ifIXsr12is_blob_typeIT0_E4typeE5valueEbE4typeERT_RS6_:
   75|   167k|{
   76|   167k|  static_assert(std::is_trivially_copyable<T>() || is_blob_forced<T>(),
   77|   167k|    "sanity check: types that can't be trivially copied shouldn't be using the blob serializer");
   78|   167k|  ar.serialize_blob(&v, sizeof(v));
   79|   167k|  return true;
   80|   167k|}
_Z12do_serializeI14binary_archiveILb0EEN3rct14multisig_kLRkiEENSt3__19enable_ifIXsr12is_blob_typeIT0_E4typeE5valueEbE4typeERT_RS6_:
   75|  2.55k|{
   76|  2.55k|  static_assert(std::is_trivially_copyable<T>() || is_blob_forced<T>(),
   77|  2.55k|    "sanity check: types that can't be trivially copied shouldn't be using the blob serializer");
   78|  2.55k|  ar.serialize_blob(&v, sizeof(v));
   79|  2.55k|  return true;
   80|  2.55k|}
_Z12do_serializeI14binary_archiveILb0EEN10cryptonote20tx_destination_entryEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|   114k|{
   90|   114k|  return v.member_do_serialize(ar);
   91|   114k|}
_ZN10cryptonote20tx_destination_entry19member_do_serializeILb0E14binary_archiveEEbRT0_IXT_EE:
  177|   114k|  bool member_do_serialize(Archive<W> &ar) {					\
  178|   114k|    ar.begin_object();							\
  179|   114k|    bool r = do_serialize_object(ar);					\
  180|   114k|    ar.end_object();							\
  181|   114k|    return r;								\
  182|   114k|  }									\
_Z12do_serializeI14binary_archiveILb0EEN10cryptonote22account_public_addressEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|   114k|{
   90|   114k|  return v.member_do_serialize(ar);
   91|   114k|}
_ZN10cryptonote22account_public_address19member_do_serializeILb0E14binary_archiveEEbRT0_IXT_EE:
  177|   114k|  bool member_do_serialize(Archive<W> &ar) {					\
  178|   114k|    ar.begin_object();							\
  179|   114k|    bool r = do_serialize_object(ar);					\
  180|   114k|    ar.end_object();							\
  181|   114k|    return r;								\
  182|   114k|  }									\
_Z12do_serializeI14binary_archiveILb0EEmENSt3__19enable_ifIXsr5boost11is_integralIT0_EE5valueEbE4typeERT_RS4_:
   83|  80.2k|{
   84|  80.2k|  ar.serialize_int(v);
   85|  80.2k|  return true;
   86|  80.2k|}
_Z12do_serializeI14binary_archiveILb0EEhENSt3__19enable_ifIXsr5boost11is_integralIT0_EE5valueEbE4typeERT_RS4_:
   83|  3.13M|{
   84|  3.13M|  ar.serialize_int(v);
   85|  3.13M|  return true;
   86|  3.13M|}
_Z12do_serializeI14binary_archiveILb0EEN3rct9RCTConfigEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|  6.34k|{
   90|  6.34k|  return v.member_do_serialize(ar);
   91|  6.34k|}
_ZN3rct9RCTConfig19member_do_serializeILb0E14binary_archiveEEbRT0_IXT_EE:
  177|  6.34k|  bool member_do_serialize(Archive<W> &ar) {					\
  178|  6.34k|    ar.begin_object();							\
  179|  6.34k|    bool r = do_serialize_object(ar);					\
  180|  6.34k|    ar.end_object();							\
  181|  6.34k|    return r;								\
  182|  6.34k|  }									\
_Z12do_serializeI14binary_archiveILb0EEjENSt3__19enable_ifIXsr5boost11is_integralIT0_EE5valueEbE4typeERT_RS4_:
   83|  27.5k|{
   84|  27.5k|  ar.serialize_int(v);
   85|  27.5k|  return true;
   86|  27.5k|}
_Z12do_serializeI14binary_archiveILb0EEN5tools7wallet216transfer_detailsEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|  12.4k|{
   90|  12.4k|  return v.member_do_serialize(ar);
   91|  12.4k|}
_ZN5tools7wallet216transfer_details19member_do_serializeILb0E14binary_archiveEEbRT0_IXT_EE:
  177|  12.4k|  bool member_do_serialize(Archive<W> &ar) {					\
  178|  12.4k|    ar.begin_object();							\
  179|  12.4k|    bool r = do_serialize_object(ar);					\
  180|  12.4k|    ar.end_object();							\
  181|  12.4k|    return r;								\
  182|  12.4k|  }									\
_Z12do_serializeI14binary_archiveILb0EEN10cryptonote18transaction_prefixEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|  12.4k|{
   90|  12.4k|  return v.member_do_serialize(ar);
   91|  12.4k|}
_ZN28variant_serialization_traitsI14binary_archiveILb0EEN10cryptonote8txin_genEE7get_tagEv:
  144|  10.2k|    static inline typename Archive<W>::variant_tag_type get_tag() {	\
  145|  10.2k|      return Tag;							\
  146|  10.2k|    }									\
_Z12do_serializeI14binary_archiveILb0EEN10cryptonote8txin_genEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|    928|{
   90|    928|  return v.member_do_serialize(ar);
   91|    928|}
_ZN10cryptonote8txin_gen19member_do_serializeILb0E14binary_archiveEEbRT0_IXT_EE:
  177|    928|  bool member_do_serialize(Archive<W> &ar) {					\
  178|    928|    ar.begin_object();							\
  179|    928|    bool r = do_serialize_object(ar);					\
  180|    928|    ar.end_object();							\
  181|    928|    return r;								\
  182|    928|  }									\
_ZN28variant_serialization_traitsI14binary_archiveILb0EEN10cryptonote14txin_to_scriptEE7get_tagEv:
  144|  9.30k|    static inline typename Archive<W>::variant_tag_type get_tag() {	\
  145|  9.30k|      return Tag;							\
  146|  9.30k|    }									\
_Z12do_serializeI14binary_archiveILb0EEN10cryptonote14txin_to_scriptEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|  2.77k|{
   90|  2.77k|  return v.member_do_serialize(ar);
   91|  2.77k|}
_ZN10cryptonote14txin_to_script19member_do_serializeILb0E14binary_archiveEEbRT0_IXT_EE:
  177|  2.77k|  bool member_do_serialize(Archive<W> &ar) {					\
  178|  2.77k|    ar.begin_object();							\
  179|  2.77k|    bool r = do_serialize_object(ar);					\
  180|  2.77k|    ar.end_object();							\
  181|  2.77k|    return r;								\
  182|  2.77k|  }									\
_ZN28variant_serialization_traitsI14binary_archiveILb0EEN10cryptonote18txin_to_scripthashEE7get_tagEv:
  144|  6.53k|    static inline typename Archive<W>::variant_tag_type get_tag() {	\
  145|  6.53k|      return Tag;							\
  146|  6.53k|    }									\
_Z12do_serializeI14binary_archiveILb0EEN10cryptonote18txin_to_scripthashEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|  3.97k|{
   90|  3.97k|  return v.member_do_serialize(ar);
   91|  3.97k|}
_ZN10cryptonote18txin_to_scripthash19member_do_serializeILb0E14binary_archiveEEbRT0_IXT_EE:
  177|  3.97k|  bool member_do_serialize(Archive<W> &ar) {					\
  178|  3.97k|    ar.begin_object();							\
  179|  3.97k|    bool r = do_serialize_object(ar);					\
  180|  3.97k|    ar.end_object();							\
  181|  3.97k|    return r;								\
  182|  3.97k|  }									\
_Z12do_serializeI14binary_archiveILb0EEN10cryptonote15txout_to_scriptEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|  13.5k|{
   90|  13.5k|  return v.member_do_serialize(ar);
   91|  13.5k|}
_ZN10cryptonote15txout_to_script19member_do_serializeILb0E14binary_archiveEEbRT0_IXT_EE:
  177|  13.5k|  bool member_do_serialize(Archive<W> &ar) {					\
  178|  13.5k|    ar.begin_object();							\
  179|  13.5k|    bool r = do_serialize_object(ar);					\
  180|  13.5k|    ar.end_object();							\
  181|  13.5k|    return r;								\
  182|  13.5k|  }									\
_ZN28variant_serialization_traitsI14binary_archiveILb0EEN10cryptonote11txin_to_keyEE7get_tagEv:
  144|  2.56k|    static inline typename Archive<W>::variant_tag_type get_tag() {	\
  145|  2.56k|      return Tag;							\
  146|  2.56k|    }									\
_Z12do_serializeI14binary_archiveILb0EEN10cryptonote11txin_to_keyEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|  2.52k|{
   90|  2.52k|  return v.member_do_serialize(ar);
   91|  2.52k|}
_ZN10cryptonote11txin_to_key19member_do_serializeILb0E14binary_archiveEEbRT0_IXT_EE:
  177|  2.52k|  bool member_do_serialize(Archive<W> &ar) {					\
  178|  2.52k|    ar.begin_object();							\
  179|  2.52k|    bool r = do_serialize_object(ar);					\
  180|  2.52k|    ar.end_object();							\
  181|  2.52k|    return r;								\
  182|  2.52k|  }									\
_Z12do_serializeI14binary_archiveILb0EEN10cryptonote6tx_outEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|  18.4k|{
   90|  18.4k|  return v.member_do_serialize(ar);
   91|  18.4k|}
_ZN10cryptonote6tx_out19member_do_serializeILb0E14binary_archiveEEbRT0_IXT_EE:
  177|  18.4k|  bool member_do_serialize(Archive<W> &ar) {					\
  178|  18.4k|    ar.begin_object();							\
  179|  18.4k|    bool r = do_serialize_object(ar);					\
  180|  18.4k|    ar.end_object();							\
  181|  18.4k|    return r;								\
  182|  18.4k|  }									\
_ZN28variant_serialization_traitsI14binary_archiveILb0EEN10cryptonote15txout_to_scriptEE7get_tagEv:
  144|  18.4k|    static inline typename Archive<W>::variant_tag_type get_tag() {	\
  145|  18.4k|      return Tag;							\
  146|  18.4k|    }									\
_ZN28variant_serialization_traitsI14binary_archiveILb0EEN10cryptonote19txout_to_scripthashEE7get_tagEv:
  144|  8.79k|    static inline typename Archive<W>::variant_tag_type get_tag() {	\
  145|  8.79k|      return Tag;							\
  146|  8.79k|    }									\
_Z12do_serializeI14binary_archiveILb0EEN10cryptonote19txout_to_scripthashEENSt3__19enable_ifIXsr12is_blob_typeIT0_E4typeE5valueEbE4typeERT_RS6_:
   75|  3.43k|{
   76|  3.43k|  static_assert(std::is_trivially_copyable<T>() || is_blob_forced<T>(),
   77|  3.43k|    "sanity check: types that can't be trivially copied shouldn't be using the blob serializer");
   78|  3.43k|  ar.serialize_blob(&v, sizeof(v));
   79|  3.43k|  return true;
   80|  3.43k|}
_ZN28variant_serialization_traitsI14binary_archiveILb0EEN10cryptonote12txout_to_keyEE7get_tagEv:
  144|  5.36k|    static inline typename Archive<W>::variant_tag_type get_tag() {	\
  145|  5.36k|      return Tag;							\
  146|  5.36k|    }									\
_Z12do_serializeI14binary_archiveILb0EEN10cryptonote12txout_to_keyEENSt3__19enable_ifIXsr12is_blob_typeIT0_E4typeE5valueEbE4typeERT_RS6_:
   75|  4.92k|{
   76|  4.92k|  static_assert(std::is_trivially_copyable<T>() || is_blob_forced<T>(),
   77|  4.92k|    "sanity check: types that can't be trivially copied shouldn't be using the blob serializer");
   78|  4.92k|  ar.serialize_blob(&v, sizeof(v));
   79|  4.92k|  return true;
   80|  4.92k|}
_ZN28variant_serialization_traitsI14binary_archiveILb0EEN10cryptonote19txout_to_tagged_keyEE7get_tagEv:
  144|    439|    static inline typename Archive<W>::variant_tag_type get_tag() {	\
  145|    439|      return Tag;							\
  146|    439|    }									\
_Z12do_serializeI14binary_archiveILb0EEN10cryptonote19txout_to_tagged_keyEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|    397|{
   90|    397|  return v.member_do_serialize(ar);
   91|    397|}
_ZN10cryptonote19txout_to_tagged_key19member_do_serializeILb0E14binary_archiveEEbRT0_IXT_EE:
  177|    397|  bool member_do_serialize(Archive<W> &ar) {					\
  178|    397|    ar.begin_object();							\
  179|    397|    bool r = do_serialize_object(ar);					\
  180|    397|    ar.end_object();							\
  181|    397|    return r;								\
  182|    397|  }									\
_Z12do_serializeI14binary_archiveILb0EEN6crypto8view_tagEENSt3__19enable_ifIXsr12is_blob_typeIT0_E4typeE5valueEbE4typeERT_RS6_:
   75|    388|{
   76|    388|  static_assert(std::is_trivially_copyable<T>() || is_blob_forced<T>(),
   77|    388|    "sanity check: types that can't be trivially copied shouldn't be using the blob serializer");
   78|    388|  ar.serialize_blob(&v, sizeof(v));
   79|    388|  return true;
   80|    388|}
_Z12do_serializeI14binary_archiveILb0EEN6crypto4hashEENSt3__19enable_ifIXsr12is_blob_typeIT0_E4typeE5valueEbE4typeERT_RS6_:
   75|  20.0k|{
   76|  20.0k|  static_assert(std::is_trivially_copyable<T>() || is_blob_forced<T>(),
   77|  20.0k|    "sanity check: types that can't be trivially copied shouldn't be using the blob serializer");
   78|  20.0k|  ar.serialize_blob(&v, sizeof(v));
   79|  20.0k|  return true;
   80|  20.0k|}
_Z12do_serializeI14binary_archiveILb0EEN6crypto9key_imageEENSt3__19enable_ifIXsr12is_blob_typeIT0_E4typeE5valueEbE4typeERT_RS6_:
   75|   122k|{
   76|   122k|  static_assert(std::is_trivially_copyable<T>() || is_blob_forced<T>(),
   77|   122k|    "sanity check: types that can't be trivially copied shouldn't be using the blob serializer");
   78|   122k|  ar.serialize_blob(&v, sizeof(v));
   79|   122k|  return true;
   80|   122k|}
_Z12do_serializeI14binary_archiveILb0EEN10cryptonote16subaddress_indexEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|  10.6k|{
   90|  10.6k|  return v.member_do_serialize(ar);
   91|  10.6k|}
_ZN10cryptonote16subaddress_index19member_do_serializeILb0E14binary_archiveEEbRT0_IXT_EE:
  177|  10.6k|  bool member_do_serialize(Archive<W> &ar) {					\
  178|  10.6k|    ar.begin_object();							\
  179|  10.6k|    bool r = do_serialize_object(ar);					\
  180|  10.6k|    ar.end_object();							\
  181|  10.6k|    return r;								\
  182|  10.6k|  }									\
_Z12do_serializeI14binary_archiveILb0EEN5tools7wallet213multisig_infoEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|  8.84k|{
   90|  8.84k|  return v.member_do_serialize(ar);
   91|  8.84k|}
_ZN5tools7wallet213multisig_info19member_do_serializeILb0E14binary_archiveEEbRT0_IXT_EE:
  177|  8.84k|  bool member_do_serialize(Archive<W> &ar) {					\
  178|  8.84k|    ar.begin_object();							\
  179|  8.84k|    bool r = do_serialize_object(ar);					\
  180|  8.84k|    ar.end_object();							\
  181|  8.84k|    return r;								\
  182|  8.84k|  }									\
_Z12do_serializeI14binary_archiveILb0EEN5tools7wallet213multisig_info2LREEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|  57.8k|{
   90|  57.8k|  return v.member_do_serialize(ar);
   91|  57.8k|}
_ZN5tools7wallet213multisig_info2LR19member_do_serializeILb0E14binary_archiveEEbRT0_IXT_EE:
  177|  57.8k|  bool member_do_serialize(Archive<W> &ar) {					\
  178|  57.8k|    ar.begin_object();							\
  179|  57.8k|    bool r = do_serialize_object(ar);					\
  180|  57.8k|    ar.end_object();							\
  181|  57.8k|    return r;								\
  182|  57.8k|  }									\
_Z12do_serializeI14binary_archiveILb0EEN5tools7wallet225exported_transfer_detailsEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|  44.1k|{
   90|  44.1k|  return v.member_do_serialize(ar);
   91|  44.1k|}
_ZN5tools7wallet225exported_transfer_details19member_do_serializeILb0E14binary_archiveEEbRT0_IXT_EE:
  177|  44.1k|  bool member_do_serialize(Archive<W> &ar) {					\
  178|  44.1k|    ar.begin_object();							\
  179|  44.1k|    bool r = do_serialize_object(ar);					\
  180|  44.1k|    ar.end_object();							\
  181|  44.1k|    return r;								\
  182|  44.1k|  }									\
_ZN13serialization18check_stream_stateI14binary_archiveILb0EEEEbRT_b:
  353|  2.68k|  {
  354|  2.68k|    return detail::do_check_stream_state(ar, typename Archive::is_saving(), noeof);
  355|  2.68k|  }
_ZN13serialization6detail21do_check_stream_stateI14binary_archiveILb0EEEEbRT_N4mpl_5bool_ILb0EEEb:
  337|  2.68k|    {
  338|  2.68k|      bool result = false;
  339|  2.68k|      if (ar.good())
  ------------------
  |  Branch (339:11): [True: 2.68k, False: 0]
  ------------------
  340|  2.68k|	{
  341|  2.68k|	  result = noeof || ar.eof();
  ------------------
  |  Branch (341:13): [True: 0, False: 2.68k]
  |  Branch (341:22): [True: 2.37k, False: 307]
  ------------------
  342|  2.68k|	}
  343|  2.68k|      return result;
  344|  2.68k|    }
_ZN13serialization6detail35prepare_custom_vector_serializationINSt3__16vectorIN6crypto9signatureENS2_9allocatorIS5_EEEEEEvmRNS3_IT_NS6_IS9_EEEERKN4mpl_5bool_ILb1EEE:
  311|      2|    {
  312|      2|    }
_ZN13serialization6detail35prepare_custom_vector_serializationIN6crypto9signatureEEEvmRNSt3__16vectorIT_NS4_9allocatorIS6_EEEERKN4mpl_5bool_ILb1EEE:
  311|      2|    {
  312|      2|    }
_ZN13serialization18check_stream_stateI14binary_archiveILb1EEEEbRT_b:
  353|  5.65k|  {
  354|  5.65k|    return detail::do_check_stream_state(ar, typename Archive::is_saving(), noeof);
  355|  5.65k|  }
_ZN13serialization6detail21do_check_stream_stateI14binary_archiveILb1EEEEbRT_N4mpl_5bool_ILb1EEEb:
  326|  5.65k|    {
  327|  5.65k|      return ar.good();
  328|  5.65k|    }
_Z12do_serializeI14binary_archiveILb1EEN6crypto10public_keyEENSt3__19enable_ifIXsr12is_blob_typeIT0_E4typeE5valueEbE4typeERT_RS6_:
   75|   115k|{
   76|   115k|  static_assert(std::is_trivially_copyable<T>() || is_blob_forced<T>(),
   77|   115k|    "sanity check: types that can't be trivially copied shouldn't be using the blob serializer");
   78|   115k|  ar.serialize_blob(&v, sizeof(v));
   79|   115k|  return true;
   80|   115k|}
_Z12do_serializeI14binary_archiveILb1EEN6crypto4hashEENSt3__19enable_ifIXsr12is_blob_typeIT0_E4typeE5valueEbE4typeERT_RS6_:
   75|     85|{
   76|     85|  static_assert(std::is_trivially_copyable<T>() || is_blob_forced<T>(),
   77|     85|    "sanity check: types that can't be trivially copied shouldn't be using the blob serializer");
   78|     85|  ar.serialize_blob(&v, sizeof(v));
   79|     85|  return true;
   80|     85|}
_Z12do_serializeI14binary_archiveILb1EEN10cryptonote18transaction_prefixEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|     24|{
   90|     24|  return v.member_do_serialize(ar);
   91|     24|}
_ZN28variant_serialization_traitsI14binary_archiveILb1EEN10cryptonote8txin_genEE7get_tagEv:
  144|     18|    static inline typename Archive<W>::variant_tag_type get_tag() {	\
  145|     18|      return Tag;							\
  146|     18|    }									\
_Z12do_serializeI14binary_archiveILb1EEN10cryptonote8txin_genEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|     18|{
   90|     18|  return v.member_do_serialize(ar);
   91|     18|}
_ZN10cryptonote8txin_gen19member_do_serializeILb1E14binary_archiveEEbRT0_IXT_EE:
  177|     18|  bool member_do_serialize(Archive<W> &ar) {					\
  178|     18|    ar.begin_object();							\
  179|     18|    bool r = do_serialize_object(ar);					\
  180|     18|    ar.end_object();							\
  181|     18|    return r;								\
  182|     18|  }									\
_ZN28variant_serialization_traitsI14binary_archiveILb1EEN10cryptonote14txin_to_scriptEE7get_tagEv:
  144|     50|    static inline typename Archive<W>::variant_tag_type get_tag() {	\
  145|     50|      return Tag;							\
  146|     50|    }									\
_Z12do_serializeI14binary_archiveILb1EEN10cryptonote14txin_to_scriptEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|     50|{
   90|     50|  return v.member_do_serialize(ar);
   91|     50|}
_ZN10cryptonote14txin_to_script19member_do_serializeILb1E14binary_archiveEEbRT0_IXT_EE:
  177|     50|  bool member_do_serialize(Archive<W> &ar) {					\
  178|     50|    ar.begin_object();							\
  179|     50|    bool r = do_serialize_object(ar);					\
  180|     50|    ar.end_object();							\
  181|     50|    return r;								\
  182|     50|  }									\
_Z12do_serializeI14binary_archiveILb1EEN10cryptonote15txout_to_scriptEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|     43|{
   90|     43|  return v.member_do_serialize(ar);
   91|     43|}
_ZN10cryptonote15txout_to_script19member_do_serializeILb1E14binary_archiveEEbRT0_IXT_EE:
  177|     43|  bool member_do_serialize(Archive<W> &ar) {					\
  178|     43|    ar.begin_object();							\
  179|     43|    bool r = do_serialize_object(ar);					\
  180|     43|    ar.end_object();							\
  181|     43|    return r;								\
  182|     43|  }									\
_ZN28variant_serialization_traitsI14binary_archiveILb1EEN10cryptonote11txin_to_keyEE7get_tagEv:
  144|     24|    static inline typename Archive<W>::variant_tag_type get_tag() {	\
  145|     24|      return Tag;							\
  146|     24|    }									\
_Z12do_serializeI14binary_archiveILb1EEN10cryptonote11txin_to_keyEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|     24|{
   90|     24|  return v.member_do_serialize(ar);
   91|     24|}
_ZN10cryptonote11txin_to_key19member_do_serializeILb1E14binary_archiveEEbRT0_IXT_EE:
  177|     24|  bool member_do_serialize(Archive<W> &ar) {					\
  178|     24|    ar.begin_object();							\
  179|     24|    bool r = do_serialize_object(ar);					\
  180|     24|    ar.end_object();							\
  181|     24|    return r;								\
  182|     24|  }									\
_Z12do_serializeI14binary_archiveILb1EEN10cryptonote6tx_outEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|     71|{
   90|     71|  return v.member_do_serialize(ar);
   91|     71|}
_ZN10cryptonote6tx_out19member_do_serializeILb1E14binary_archiveEEbRT0_IXT_EE:
  177|     71|  bool member_do_serialize(Archive<W> &ar) {					\
  178|     71|    ar.begin_object();							\
  179|     71|    bool r = do_serialize_object(ar);					\
  180|     71|    ar.end_object();							\
  181|     71|    return r;								\
  182|     71|  }									\
_ZN28variant_serialization_traitsI14binary_archiveILb1EEN10cryptonote15txout_to_scriptEE7get_tagEv:
  144|     43|    static inline typename Archive<W>::variant_tag_type get_tag() {	\
  145|     43|      return Tag;							\
  146|     43|    }									\
_ZN28variant_serialization_traitsI14binary_archiveILb1EEN10cryptonote19txout_to_scripthashEE7get_tagEv:
  144|      1|    static inline typename Archive<W>::variant_tag_type get_tag() {	\
  145|      1|      return Tag;							\
  146|      1|    }									\
_Z12do_serializeI14binary_archiveILb1EEN10cryptonote19txout_to_scripthashEENSt3__19enable_ifIXsr12is_blob_typeIT0_E4typeE5valueEbE4typeERT_RS6_:
   75|      1|{
   76|      1|  static_assert(std::is_trivially_copyable<T>() || is_blob_forced<T>(),
   77|      1|    "sanity check: types that can't be trivially copied shouldn't be using the blob serializer");
   78|      1|  ar.serialize_blob(&v, sizeof(v));
   79|      1|  return true;
   80|      1|}
_ZN28variant_serialization_traitsI14binary_archiveILb1EEN10cryptonote12txout_to_keyEE7get_tagEv:
  144|     23|    static inline typename Archive<W>::variant_tag_type get_tag() {	\
  145|     23|      return Tag;							\
  146|     23|    }									\
_Z12do_serializeI14binary_archiveILb1EEN10cryptonote12txout_to_keyEENSt3__19enable_ifIXsr12is_blob_typeIT0_E4typeE5valueEbE4typeERT_RS6_:
   75|     23|{
   76|     23|  static_assert(std::is_trivially_copyable<T>() || is_blob_forced<T>(),
   77|     23|    "sanity check: types that can't be trivially copied shouldn't be using the blob serializer");
   78|     23|  ar.serialize_blob(&v, sizeof(v));
   79|     23|  return true;
   80|     23|}
_ZN28variant_serialization_traitsI14binary_archiveILb1EEN10cryptonote19txout_to_tagged_keyEE7get_tagEv:
  144|      4|    static inline typename Archive<W>::variant_tag_type get_tag() {	\
  145|      4|      return Tag;							\
  146|      4|    }									\
_Z12do_serializeI14binary_archiveILb1EEN10cryptonote19txout_to_tagged_keyEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|      4|{
   90|      4|  return v.member_do_serialize(ar);
   91|      4|}
_ZN10cryptonote19txout_to_tagged_key19member_do_serializeILb1E14binary_archiveEEbRT0_IXT_EE:
  177|      4|  bool member_do_serialize(Archive<W> &ar) {					\
  178|      4|    ar.begin_object();							\
  179|      4|    bool r = do_serialize_object(ar);					\
  180|      4|    ar.end_object();							\
  181|      4|    return r;								\
  182|      4|  }									\
_Z12do_serializeI14binary_archiveILb1EEN6crypto8view_tagEENSt3__19enable_ifIXsr12is_blob_typeIT0_E4typeE5valueEbE4typeERT_RS6_:
   75|      4|{
   76|      4|  static_assert(std::is_trivially_copyable<T>() || is_blob_forced<T>(),
   77|      4|    "sanity check: types that can't be trivially copied shouldn't be using the blob serializer");
   78|      4|  ar.serialize_blob(&v, sizeof(v));
   79|      4|  return true;
   80|      4|}
_Z12do_serializeI14binary_archiveILb1EEhENSt3__19enable_ifIXsr5boost11is_integralIT0_EE5valueEbE4typeERT_RS4_:
   83|   107k|{
   84|   107k|  ar.serialize_int(v);
   85|   107k|  return true;
   86|   107k|}
_Z12do_serializeI14binary_archiveILb1EEN6crypto9key_imageEENSt3__19enable_ifIXsr12is_blob_typeIT0_E4typeE5valueEbE4typeERT_RS6_:
   75|  35.3k|{
   76|  35.3k|  static_assert(std::is_trivially_copyable<T>() || is_blob_forced<T>(),
   77|  35.3k|    "sanity check: types that can't be trivially copied shouldn't be using the blob serializer");
   78|  35.3k|  ar.serialize_blob(&v, sizeof(v));
   79|  35.3k|  return true;
   80|  35.3k|}
_Z12do_serializeI14binary_archiveILb1EEjENSt3__19enable_ifIXsr5boost11is_integralIT0_EE5valueEbE4typeERT_RS4_:
   83|      3|{
   84|      3|  ar.serialize_int(v);
   85|      3|  return true;
   86|      3|}
_ZN13serialization9serializeI14binary_archiveILb1EEN5tools7wallet213signed_tx_setEEEbRT_RT0_:
  363|  5.59k|  {
  364|  5.59k|    bool r = do_serialize(ar, v);
  365|  5.59k|    return r && check_stream_state(ar, false);
  ------------------
  |  Branch (365:12): [True: 5.59k, False: 0]
  |  Branch (365:17): [True: 5.59k, False: 0]
  ------------------
  366|  5.59k|  }
_Z12do_serializeI14binary_archiveILb1EEN5tools7wallet213signed_tx_setEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|  5.59k|{
   90|  5.59k|  return v.member_do_serialize(ar);
   91|  5.59k|}
_ZN5tools7wallet213signed_tx_set19member_do_serializeILb1E14binary_archiveEEbRT0_IXT_EE:
  177|  5.59k|  bool member_do_serialize(Archive<W> &ar) {					\
  178|  5.59k|    ar.begin_object();							\
  179|  5.59k|    bool r = do_serialize_object(ar);					\
  180|  5.59k|    ar.end_object();							\
  181|  5.59k|    return r;								\
  182|  5.59k|  }									\
_Z12do_serializeI14binary_archiveILb1EEN10cryptonote11transactionEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|      2|{
   90|      2|  return v.member_do_serialize(ar);
   91|      2|}
_ZN10cryptonote11transaction19member_do_serializeILb1E14binary_archiveEEbRT0_IXT_EE:
  177|      2|  bool member_do_serialize(Archive<W> &ar) {					\
  178|      2|    ar.begin_object();							\
  179|      2|    bool r = do_serialize_object(ar);					\
  180|      2|    ar.end_object();							\
  181|      2|    return r;								\
  182|      2|  }									\
_Z12do_serializeI14binary_archiveILb0EEN10cryptonote11transactionEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|      1|{
   90|      1|  return v.member_do_serialize(ar);
   91|      1|}
_ZN10cryptonote11transaction19member_do_serializeILb0E14binary_archiveEEbRT0_IXT_EE:
  177|      1|  bool member_do_serialize(Archive<W> &ar) {					\
  178|      1|    ar.begin_object();							\
  179|      1|    bool r = do_serialize_object(ar);					\
  180|      1|    ar.end_object();							\
  181|      1|    return r;								\
  182|      1|  }									\
_ZN13serialization6detail35prepare_custom_vector_serializationINSt3__16vectorIN6crypto9signatureENS2_9allocatorIS5_EEEEEEvmRNS3_IT_NS6_IS9_EEEERKN4mpl_5bool_ILb0EEE:
  316|      1|    {
  317|      1|      vec.resize(size);
  318|      1|    }
_ZN13serialization6detail35prepare_custom_vector_serializationIN6crypto9signatureEEEvmRNSt3__16vectorIT_NS4_9allocatorIS6_EEEERKN4mpl_5bool_ILb0EEE:
  316|      1|    {
  317|      1|      vec.resize(size);
  318|      1|    }
_ZN13serialization9serializeI14binary_archiveILb1EEN10cryptonote11transactionEEEbRT_RT0_:
  363|      1|  {
  364|      1|    bool r = do_serialize(ar, v);
  365|      1|    return r && check_stream_state(ar, false);
  ------------------
  |  Branch (365:12): [True: 1, False: 0]
  |  Branch (365:17): [True: 1, False: 0]
  ------------------
  366|      1|  }
_ZN13serialization9serializeI14binary_archiveILb1EEN10cryptonote18transaction_prefixEEEbRT_RT0_:
  363|     22|  {
  364|     22|    bool r = do_serialize(ar, v);
  365|     22|    return r && check_stream_state(ar, false);
  ------------------
  |  Branch (365:12): [True: 22, False: 0]
  |  Branch (365:17): [True: 22, False: 0]
  ------------------
  366|     22|  }
_ZN13serialization9serializeI14binary_archiveILb0EEN10cryptonote11transactionEEEbRT_RT0_:
  363|      1|  {
  364|      1|    bool r = do_serialize(ar, v);
  365|      1|    return r && check_stream_state(ar, false);
  ------------------
  |  Branch (365:12): [True: 1, False: 0]
  |  Branch (365:17): [True: 1, False: 0]
  ------------------
  366|      1|  }
_ZN28variant_serialization_traitsI14binary_archiveILb0EEN10cryptonote16tx_extra_paddingEE7get_tagEv:
  144|  21.8k|    static inline typename Archive<W>::variant_tag_type get_tag() {	\
  145|  21.8k|      return Tag;							\
  146|  21.8k|    }									\
_Z12do_serializeI14binary_archiveILb0EEN10cryptonote16tx_extra_paddingEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|    557|{
   90|    557|  return v.member_do_serialize(ar);
   91|    557|}
_ZN28variant_serialization_traitsI14binary_archiveILb0EEN10cryptonote16tx_extra_pub_keyEE7get_tagEv:
  144|  21.3k|    static inline typename Archive<W>::variant_tag_type get_tag() {	\
  145|  21.3k|      return Tag;							\
  146|  21.3k|    }									\
_Z12do_serializeI14binary_archiveILb0EEN10cryptonote16tx_extra_pub_keyEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|  5.07k|{
   90|  5.07k|  return v.member_do_serialize(ar);
   91|  5.07k|}
_ZN28variant_serialization_traitsI14binary_archiveILb0EEN10cryptonote14tx_extra_nonceEE7get_tagEv:
  144|  16.2k|    static inline typename Archive<W>::variant_tag_type get_tag() {	\
  145|  16.2k|      return Tag;							\
  146|  16.2k|    }									\
_Z12do_serializeI14binary_archiveILb0EEN10cryptonote14tx_extra_nonceEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|  11.5k|{
   90|  11.5k|  return v.member_do_serialize(ar);
   91|  11.5k|}
_ZN28variant_serialization_traitsI14binary_archiveILb0EEN10cryptonote25tx_extra_merge_mining_tagEE7get_tagEv:
  144|  4.71k|    static inline typename Archive<W>::variant_tag_type get_tag() {	\
  145|  4.71k|      return Tag;							\
  146|  4.71k|    }									\
_Z12do_serializeI14binary_archiveILb0EEN10cryptonote25tx_extra_merge_mining_tagEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|    143|{
   90|    143|  return v.member_do_serialize(ar);
   91|    143|}
_ZN13serialization9serializeI14binary_archiveILb0EEN10cryptonote25tx_extra_merge_mining_tag16serialize_helperEEEbRT_RT0_:
  363|    137|  {
  364|    137|    bool r = do_serialize(ar, v);
  365|    137|    return r && check_stream_state(ar, false);
  ------------------
  |  Branch (365:12): [True: 99, False: 38]
  |  Branch (365:17): [True: 93, False: 6]
  ------------------
  366|    137|  }
_Z12do_serializeI14binary_archiveILb0EEN10cryptonote25tx_extra_merge_mining_tag16serialize_helperEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|    137|{
   90|    137|  return v.member_do_serialize(ar);
   91|    137|}
_ZN28variant_serialization_traitsI14binary_archiveILb0EEN10cryptonote28tx_extra_additional_pub_keysEE7get_tagEv:
  144|  4.57k|    static inline typename Archive<W>::variant_tag_type get_tag() {	\
  145|  4.57k|      return Tag;							\
  146|  4.57k|    }									\
_Z12do_serializeI14binary_archiveILb0EEN10cryptonote28tx_extra_additional_pub_keysEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|  1.41k|{
   90|  1.41k|  return v.member_do_serialize(ar);
   91|  1.41k|}
_ZN28variant_serialization_traitsI14binary_archiveILb0EEN10cryptonote29tx_extra_mysterious_minergateEE7get_tagEv:
  144|  3.16k|    static inline typename Archive<W>::variant_tag_type get_tag() {	\
  145|  3.16k|      return Tag;							\
  146|  3.16k|    }									\
_Z12do_serializeI14binary_archiveILb0EEN10cryptonote29tx_extra_mysterious_minergateEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|  2.91k|{
   90|  2.91k|  return v.member_do_serialize(ar);
   91|  2.91k|}
_Z12do_serializeI14binary_archiveILb1EEN10cryptonote16tx_extra_pub_keyEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|    453|{
   90|    453|  return v.member_do_serialize(ar);
   91|    453|}
_Z12do_serializeI14binary_archiveILb1EEN10cryptonote28tx_extra_additional_pub_keysEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|    266|{
   90|    266|  return v.member_do_serialize(ar);
   91|    266|}
_Z12do_serializeI14binary_archiveILb1EEN10cryptonote25tx_extra_merge_mining_tagEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|     32|{
   90|     32|  return v.member_do_serialize(ar);
   91|     32|}
_Z12do_serializeI14binary_archiveILb1EEN10cryptonote25tx_extra_merge_mining_tag16serialize_helperEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|     32|{
   90|     32|  return v.member_do_serialize(ar);
   91|     32|}
_ZN13serialization9serializeI14binary_archiveILb1EENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEbRT_RT0_:
  363|     33|  {
  364|     33|    bool r = do_serialize(ar, v);
  365|     33|    return r && check_stream_state(ar, false);
  ------------------
  |  Branch (365:12): [True: 33, False: 0]
  |  Branch (365:17): [True: 33, False: 0]
  ------------------
  366|     33|  }
_Z12do_serializeI14binary_archiveILb1EEN10cryptonote29tx_extra_mysterious_minergateEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|    957|{
   90|    957|  return v.member_do_serialize(ar);
   91|    957|}
_Z12do_serializeI14binary_archiveILb1EEN10cryptonote16tx_extra_paddingEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|     89|{
   90|     89|  return v.member_do_serialize(ar);
   91|     89|}
_ZN28variant_serialization_traitsI14binary_archiveILb1EEN10cryptonote16tx_extra_paddingEE7get_tagEv:
  144|     89|    static inline typename Archive<W>::variant_tag_type get_tag() {	\
  145|     89|      return Tag;							\
  146|     89|    }									\
_ZN28variant_serialization_traitsI14binary_archiveILb1EEN10cryptonote16tx_extra_pub_keyEE7get_tagEv:
  144|    453|    static inline typename Archive<W>::variant_tag_type get_tag() {	\
  145|    453|      return Tag;							\
  146|    453|    }									\
_ZN28variant_serialization_traitsI14binary_archiveILb1EEN10cryptonote25tx_extra_merge_mining_tagEE7get_tagEv:
  144|     32|    static inline typename Archive<W>::variant_tag_type get_tag() {	\
  145|     32|      return Tag;							\
  146|     32|    }									\
_ZN28variant_serialization_traitsI14binary_archiveILb1EEN10cryptonote28tx_extra_additional_pub_keysEE7get_tagEv:
  144|    266|    static inline typename Archive<W>::variant_tag_type get_tag() {	\
  145|    266|      return Tag;							\
  146|    266|    }									\
_ZN28variant_serialization_traitsI14binary_archiveILb1EEN10cryptonote29tx_extra_mysterious_minergateEE7get_tagEv:
  144|    957|    static inline typename Archive<W>::variant_tag_type get_tag() {	\
  145|    957|      return Tag;							\
  146|    957|    }									\
_ZN13serialization9serializeI14binary_archiveILb1EEN10cryptonote12block_headerEEEbRT_RT0_:
  363|      2|  {
  364|      2|    bool r = do_serialize(ar, v);
  365|      2|    return r && check_stream_state(ar, false);
  ------------------
  |  Branch (365:12): [True: 2, False: 0]
  |  Branch (365:17): [True: 2, False: 0]
  ------------------
  366|      2|  }
_Z12do_serializeI14binary_archiveILb1EEN10cryptonote12block_headerEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|      3|{
   90|      3|  return v.member_do_serialize(ar);
   91|      3|}
_ZN13serialization9serializeI14binary_archiveILb1EEN10cryptonote5blockEEEbRT_RT0_:
  363|      1|  {
  364|      1|    bool r = do_serialize(ar, v);
  365|      1|    return r && check_stream_state(ar, false);
  ------------------
  |  Branch (365:12): [True: 1, False: 0]
  |  Branch (365:17): [True: 1, False: 0]
  ------------------
  366|      1|  }
_Z12do_serializeI14binary_archiveILb1EEN10cryptonote5blockEEDTcmcldtfp0_19member_do_serializefp_ELb1EERT_RT0_:
   89|      1|{
   90|      1|  return v.member_do_serialize(ar);
   91|      1|}
_ZN10cryptonote5block19member_do_serializeILb1E14binary_archiveEEbRT0_IXT_EE:
  177|      1|  bool member_do_serialize(Archive<W> &ar) {					\
  178|      1|    ar.begin_object();							\
  179|      1|    bool r = do_serialize_object(ar);					\
  180|      1|    ar.end_object();							\
  181|      1|    return r;								\
  182|      1|  }									\

_Z12do_serializeI14binary_archiveEbRT_ILb0EERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE:
   37|   128k|{
   38|   128k|  size_t size = 0;
   39|   128k|  ar.serialize_varint(size);
   40|   128k|  if (ar.remaining_bytes() < size)
  ------------------
  |  Branch (40:7): [True: 305, False: 128k]
  ------------------
   41|    305|  {
   42|    305|    ar.set_fail();
   43|    305|    return false;
   44|    305|  }
   45|       |
   46|   128k|  std::unique_ptr<std::string::value_type[]> buf(new std::string::value_type[size]);
   47|   128k|  ar.serialize_blob(buf.get(), size);
   48|   128k|  str.erase();
   49|   128k|  str.append(buf.get(), size);
   50|   128k|  return true;
   51|   128k|}
_Z12do_serializeI14binary_archiveEbRT_ILb1EERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE:
   56|    990|{
   57|    990|  size_t size = str.size();
   58|    990|  ar.serialize_varint(size);
   59|    990|  ar.serialize_blob(const_cast<std::string::value_type*>(str.c_str()), size);
   60|    990|  return true;
   61|    990|}

_Z12do_serializeILb0E14binary_archiveJmmNSt3__16vectorIN5tools7wallet225exported_transfer_detailsENS1_9allocatorIS5_EEEEEEbRT0_IXT_EERNS1_5tupleIJDpT1_EEE:
  103|  1.12k|{
  104|  1.12k|  return do_serialize_tuple<true>(ar, v);
  105|  1.12k|}
_Z18do_serialize_tupleILb1ELb0E14binary_archiveJmmNSt3__16vectorIN5tools7wallet225exported_transfer_detailsENS1_9allocatorIS5_EEEEEEbRT1_IXT0_EERNS1_5tupleIJDpT2_EEE:
   97|  1.12k|{
   98|  1.12k|  return do_serialize_tuple_nth<0, BackwardsCompat>(ar, v);
   99|  1.12k|}
_Z22do_serialize_tuple_nthILm0ELb1ELb0E14binary_archiveJmmNSt3__16vectorIN5tools7wallet225exported_transfer_detailsENS1_9allocatorIS5_EEEEEEbRT2_IXT1_EERNS1_5tupleIJDpT3_EEE:
   56|  1.12k|{
   57|  1.12k|  static constexpr const size_t tuple_size = std::tuple_size<std::tuple<Ts...>>();
   58|  1.12k|  static_assert(I <= tuple_size, "bad call");
   59|       |
   60|       |  if constexpr (I == 0)
   61|  1.12k|  {
   62|       |    // If BackwardsCompat is true, we serialize the size of 3-tuples and 4-tuples
   63|       |    if constexpr (BackwardsCompat && (tuple_size == 3 || tuple_size == 4))
   64|  1.12k|    {
   65|  1.12k|      size_t cnt = tuple_size;
   66|  1.12k|      ar.begin_array(cnt);
   67|  1.12k|      if (cnt != tuple_size)
  ------------------
  |  Branch (67:11): [True: 754, False: 375]
  ------------------
   68|    754|        return false;
   69|       |    }
   70|       |    else
   71|       |    {
   72|       |      ar.begin_array();
   73|       |    }
   74|       |  }
   75|       |  else if constexpr (I < tuple_size)
   76|       |  {
   77|       |    ar.delimit_array();
   78|       |  }
   79|       |
   80|       |  if constexpr (I == tuple_size)
   81|       |  {
   82|       |    ar.end_array();
   83|       |    return ar.good();
   84|       |  }
   85|       |  else
   86|  1.12k|  {
   87|  1.12k|    if (!::serialization::detail::serialize_tuple_element(ar, std::get<I>(v))
  ------------------
  |  Branch (87:9): [True: 754, False: 375]
  ------------------
   88|  1.12k|        || !ar.good())
  ------------------
  |  Branch (88:12): [True: 9, False: 366]
  ------------------
   89|      9|      return false;
   90|       |
   91|  1.12k|    return do_serialize_tuple_nth<I + 1, BackwardsCompat>(ar, v);
   92|  1.12k|  }
   93|  1.12k|}
_ZN13serialization6detail23serialize_tuple_elementI14binary_archiveILb0EEEEbRT_Rm:
   47|    741|    {
   48|    741|      ar.serialize_varint(e);
   49|    741|      return true;
   50|    741|    }
_Z22do_serialize_tuple_nthILm1ELb1ELb0E14binary_archiveJmmNSt3__16vectorIN5tools7wallet225exported_transfer_detailsENS1_9allocatorIS5_EEEEEEbRT2_IXT1_EERNS1_5tupleIJDpT3_EEE:
   56|    366|{
   57|    366|  static constexpr const size_t tuple_size = std::tuple_size<std::tuple<Ts...>>();
   58|    366|  static_assert(I <= tuple_size, "bad call");
   59|       |
   60|       |  if constexpr (I == 0)
   61|       |  {
   62|       |    // If BackwardsCompat is true, we serialize the size of 3-tuples and 4-tuples
   63|       |    if constexpr (BackwardsCompat && (tuple_size == 3 || tuple_size == 4))
   64|       |    {
   65|       |      size_t cnt = tuple_size;
   66|       |      ar.begin_array(cnt);
   67|       |      if (cnt != tuple_size)
   68|       |        return false;
   69|       |    }
   70|       |    else
   71|       |    {
   72|       |      ar.begin_array();
   73|       |    }
   74|       |  }
   75|       |  else if constexpr (I < tuple_size)
   76|    366|  {
   77|    366|    ar.delimit_array();
   78|    366|  }
   79|       |
   80|       |  if constexpr (I == tuple_size)
   81|       |  {
   82|       |    ar.end_array();
   83|       |    return ar.good();
   84|       |  }
   85|       |  else
   86|    366|  {
   87|    366|    if (!::serialization::detail::serialize_tuple_element(ar, std::get<I>(v))
  ------------------
  |  Branch (87:9): [True: 0, False: 366]
  ------------------
   88|    366|        || !ar.good())
  ------------------
  |  Branch (88:12): [True: 5, False: 361]
  ------------------
   89|      5|      return false;
   90|       |
   91|    361|    return do_serialize_tuple_nth<I + 1, BackwardsCompat>(ar, v);
   92|    366|  }
   93|    366|}
_Z22do_serialize_tuple_nthILm2ELb1ELb0E14binary_archiveJmmNSt3__16vectorIN5tools7wallet225exported_transfer_detailsENS1_9allocatorIS5_EEEEEEbRT2_IXT1_EERNS1_5tupleIJDpT3_EEE:
   56|    361|{
   57|    361|  static constexpr const size_t tuple_size = std::tuple_size<std::tuple<Ts...>>();
   58|    361|  static_assert(I <= tuple_size, "bad call");
   59|       |
   60|       |  if constexpr (I == 0)
   61|       |  {
   62|       |    // If BackwardsCompat is true, we serialize the size of 3-tuples and 4-tuples
   63|       |    if constexpr (BackwardsCompat && (tuple_size == 3 || tuple_size == 4))
   64|       |    {
   65|       |      size_t cnt = tuple_size;
   66|       |      ar.begin_array(cnt);
   67|       |      if (cnt != tuple_size)
   68|       |        return false;
   69|       |    }
   70|       |    else
   71|       |    {
   72|       |      ar.begin_array();
   73|       |    }
   74|       |  }
   75|       |  else if constexpr (I < tuple_size)
   76|    361|  {
   77|    361|    ar.delimit_array();
   78|    361|  }
   79|       |
   80|       |  if constexpr (I == tuple_size)
   81|       |  {
   82|       |    ar.end_array();
   83|       |    return ar.good();
   84|       |  }
   85|       |  else
   86|    361|  {
   87|    361|    if (!::serialization::detail::serialize_tuple_element(ar, std::get<I>(v))
  ------------------
  |  Branch (87:9): [True: 298, False: 63]
  ------------------
   88|    361|        || !ar.good())
  ------------------
  |  Branch (88:12): [True: 0, False: 63]
  ------------------
   89|    298|      return false;
   90|       |
   91|     63|    return do_serialize_tuple_nth<I + 1, BackwardsCompat>(ar, v);
   92|    361|  }
   93|    361|}
_ZN13serialization6detail23serialize_tuple_elementI14binary_archiveILb0EENSt3__16vectorIN5tools7wallet225exported_transfer_detailsENS4_9allocatorIS8_EEEEEEbRT_RT0_:
   41|    361|    {
   42|    361|      return do_serialize(ar, e);
   43|    361|    }
_Z22do_serialize_tuple_nthILm3ELb1ELb0E14binary_archiveJmmNSt3__16vectorIN5tools7wallet225exported_transfer_detailsENS1_9allocatorIS5_EEEEEEbRT2_IXT1_EERNS1_5tupleIJDpT3_EEE:
   56|     63|{
   57|     63|  static constexpr const size_t tuple_size = std::tuple_size<std::tuple<Ts...>>();
   58|     63|  static_assert(I <= tuple_size, "bad call");
   59|       |
   60|       |  if constexpr (I == 0)
   61|       |  {
   62|       |    // If BackwardsCompat is true, we serialize the size of 3-tuples and 4-tuples
   63|       |    if constexpr (BackwardsCompat && (tuple_size == 3 || tuple_size == 4))
   64|       |    {
   65|       |      size_t cnt = tuple_size;
   66|       |      ar.begin_array(cnt);
   67|       |      if (cnt != tuple_size)
   68|       |        return false;
   69|       |    }
   70|       |    else
   71|       |    {
   72|       |      ar.begin_array();
   73|       |    }
   74|       |  }
   75|     63|  else if constexpr (I < tuple_size)
   76|     63|  {
   77|     63|    ar.delimit_array();
   78|     63|  }
   79|       |
   80|       |  if constexpr (I == tuple_size)
   81|     63|  {
   82|     63|    ar.end_array();
   83|     63|    return ar.good();
   84|       |  }
   85|       |  else
   86|       |  {
   87|       |    if (!::serialization::detail::serialize_tuple_element(ar, std::get<I>(v))
   88|       |        || !ar.good())
   89|       |      return false;
   90|       |
   91|       |    return do_serialize_tuple_nth<I + 1, BackwardsCompat>(ar, v);
   92|       |  }
   93|     63|}

cold-transaction.cpp:_ZL12do_serializeI14binary_archiveJN10cryptonote8txin_genENS1_14txin_to_scriptENS1_18txin_to_scripthashENS1_11txin_to_keyEEEbRT_ILb0EERN5boost7variantIDpT0_EE:
  105|  10.2k|static bool do_serialize(Archive<false> &ar, boost::variant<T...> &v) {
  106|  10.2k|    using types = typename boost::variant<T...>::types;
  107|  10.2k|    typename Archive<false>::variant_tag_type t;
  108|  10.2k|    ar.begin_variant();
  109|  10.2k|    ar.read_variant_tag(t);
  110|  10.2k|    if(!variant_reader<Archive<false>, boost::variant<T...>,
  ------------------
  |  Branch (110:8): [True: 537, False: 9.70k]
  ------------------
  111|  10.2k|       typename boost::mpl::begin<types>::type,
  112|  10.2k|       typename boost::mpl::end<types>::type>::read(ar, v, t))
  113|    537|    {
  114|    537|      ar.set_fail();
  115|    537|      return false;
  116|    537|    }
  117|  9.70k|    ar.end_variant();
  118|  9.70k|    return true;
  119|  10.2k|}
_ZN14variant_readerI14binary_archiveILb0EEN5boost7variantIN10cryptonote8txin_genEJNS4_14txin_to_scriptENS4_18txin_to_scripthashENS4_11txin_to_keyEEEENS2_3mpl6l_iterINSA_6l_itemIN4mpl_5long_ILl4EEES5_NSC_INSE_ILl3EEES6_NSC_INSE_ILl2EEES7_NSC_INSE_ILl1EEES8_NSA_5l_endEEEEEEEEEEENSB_ISJ_EEE4readERS1_RS9_h:
   73|  10.2k|  {
   74|  10.2k|    if(variant_serialization_traits<Archive, current_type>::get_tag() == t) {
  ------------------
  |  Branch (74:8): [True: 928, False: 9.30k]
  ------------------
   75|    928|      current_type x;
   76|    928|      if(!do_serialize(ar, x))
  ------------------
  |  Branch (76:10): [True: 14, False: 914]
  ------------------
   77|     14|      {
   78|     14|        ar.set_fail();
   79|     14|        return false;
   80|     14|      }
   81|    914|      v = x;
   82|  9.30k|    } else {
   83|       |      // Tail recursive.... but no mutation is going on. Why?
   84|  9.30k|      return variant_reader<Archive, Variant, TNext, TEnd>::read(ar, v, t);
   85|  9.30k|    }
   86|    914|    return true;
   87|  10.2k|  }
_ZN14variant_readerI14binary_archiveILb0EEN5boost7variantIN10cryptonote8txin_genEJNS4_14txin_to_scriptENS4_18txin_to_scripthashENS4_11txin_to_keyEEEENS2_3mpl6l_iterINSA_6l_itemIN4mpl_5long_ILl3EEES6_NSC_INSE_ILl2EEES7_NSC_INSE_ILl1EEES8_NSA_5l_endEEEEEEEEENSB_ISI_EEE4readERS1_RS9_h:
   73|  9.30k|  {
   74|  9.30k|    if(variant_serialization_traits<Archive, current_type>::get_tag() == t) {
  ------------------
  |  Branch (74:8): [True: 2.77k, False: 6.53k]
  ------------------
   75|  2.77k|      current_type x;
   76|  2.77k|      if(!do_serialize(ar, x))
  ------------------
  |  Branch (76:10): [True: 157, False: 2.61k]
  ------------------
   77|    157|      {
   78|    157|        ar.set_fail();
   79|    157|        return false;
   80|    157|      }
   81|  2.61k|      v = x;
   82|  6.53k|    } else {
   83|       |      // Tail recursive.... but no mutation is going on. Why?
   84|  6.53k|      return variant_reader<Archive, Variant, TNext, TEnd>::read(ar, v, t);
   85|  6.53k|    }
   86|  2.61k|    return true;
   87|  9.30k|  }
_ZN14variant_readerI14binary_archiveILb0EEN5boost7variantIN10cryptonote8txin_genEJNS4_14txin_to_scriptENS4_18txin_to_scripthashENS4_11txin_to_keyEEEENS2_3mpl6l_iterINSA_6l_itemIN4mpl_5long_ILl2EEES7_NSC_INSE_ILl1EEES8_NSA_5l_endEEEEEEENSB_ISH_EEE4readERS1_RS9_h:
   73|  6.53k|  {
   74|  6.53k|    if(variant_serialization_traits<Archive, current_type>::get_tag() == t) {
  ------------------
  |  Branch (74:8): [True: 3.97k, False: 2.56k]
  ------------------
   75|  3.97k|      current_type x;
   76|  3.97k|      if(!do_serialize(ar, x))
  ------------------
  |  Branch (76:10): [True: 75, False: 3.90k]
  ------------------
   77|     75|      {
   78|     75|        ar.set_fail();
   79|     75|        return false;
   80|     75|      }
   81|  3.90k|      v = x;
   82|  3.90k|    } else {
   83|       |      // Tail recursive.... but no mutation is going on. Why?
   84|  2.56k|      return variant_reader<Archive, Variant, TNext, TEnd>::read(ar, v, t);
   85|  2.56k|    }
   86|  3.90k|    return true;
   87|  6.53k|  }
_ZN14variant_readerI14binary_archiveILb0EEN5boost7variantIN10cryptonote8txin_genEJNS4_14txin_to_scriptENS4_18txin_to_scripthashENS4_11txin_to_keyEEEENS2_3mpl6l_iterINSA_6l_itemIN4mpl_5long_ILl1EEES8_NSA_5l_endEEEEENSB_ISG_EEE4readERS1_RS9_h:
   73|  2.56k|  {
   74|  2.56k|    if(variant_serialization_traits<Archive, current_type>::get_tag() == t) {
  ------------------
  |  Branch (74:8): [True: 2.52k, False: 32]
  ------------------
   75|  2.52k|      current_type x;
   76|  2.52k|      if(!do_serialize(ar, x))
  ------------------
  |  Branch (76:10): [True: 259, False: 2.27k]
  ------------------
   77|    259|      {
   78|    259|        ar.set_fail();
   79|    259|        return false;
   80|    259|      }
   81|  2.27k|      v = x;
   82|  2.27k|    } else {
   83|       |      // Tail recursive.... but no mutation is going on. Why?
   84|     32|      return variant_reader<Archive, Variant, TNext, TEnd>::read(ar, v, t);
   85|     32|    }
   86|  2.27k|    return true;
   87|  2.56k|  }
_ZN14variant_readerI14binary_archiveILb0EEN5boost7variantIN10cryptonote8txin_genEJNS4_14txin_to_scriptENS4_18txin_to_scripthashENS4_11txin_to_keyEEEENS2_3mpl6l_iterINSA_5l_endEEESD_E4readERS1_RS9_h:
   98|     32|  {
   99|     32|    ar.set_fail();
  100|     32|    return false;
  101|     32|  }
cold-transaction.cpp:_ZL12do_serializeI14binary_archiveJN10cryptonote15txout_to_scriptENS1_19txout_to_scripthashENS1_12txout_to_keyENS1_19txout_to_tagged_keyEEEbRT_ILb0EERN5boost7variantIDpT0_EE:
  105|  18.4k|static bool do_serialize(Archive<false> &ar, boost::variant<T...> &v) {
  106|  18.4k|    using types = typename boost::variant<T...>::types;
  107|  18.4k|    typename Archive<false>::variant_tag_type t;
  108|  18.4k|    ar.begin_variant();
  109|  18.4k|    ar.read_variant_tag(t);
  110|  18.4k|    if(!variant_reader<Archive<false>, boost::variant<T...>,
  ------------------
  |  Branch (110:8): [True: 340, False: 18.1k]
  ------------------
  111|  18.4k|       typename boost::mpl::begin<types>::type,
  112|  18.4k|       typename boost::mpl::end<types>::type>::read(ar, v, t))
  113|    340|    {
  114|    340|      ar.set_fail();
  115|    340|      return false;
  116|    340|    }
  117|  18.1k|    ar.end_variant();
  118|  18.1k|    return true;
  119|  18.4k|}
_ZN14variant_readerI14binary_archiveILb0EEN5boost7variantIN10cryptonote15txout_to_scriptEJNS4_19txout_to_scripthashENS4_12txout_to_keyENS4_19txout_to_tagged_keyEEEENS2_3mpl6l_iterINSA_6l_itemIN4mpl_5long_ILl4EEES5_NSC_INSE_ILl3EEES6_NSC_INSE_ILl2EEES7_NSC_INSE_ILl1EEES8_NSA_5l_endEEEEEEEEEEENSB_ISJ_EEE4readERS1_RS9_h:
   73|  18.4k|  {
   74|  18.4k|    if(variant_serialization_traits<Archive, current_type>::get_tag() == t) {
  ------------------
  |  Branch (74:8): [True: 9.65k, False: 8.79k]
  ------------------
   75|  9.65k|      current_type x;
   76|  9.65k|      if(!do_serialize(ar, x))
  ------------------
  |  Branch (76:10): [True: 288, False: 9.36k]
  ------------------
   77|    288|      {
   78|    288|        ar.set_fail();
   79|    288|        return false;
   80|    288|      }
   81|  9.36k|      v = x;
   82|  9.36k|    } else {
   83|       |      // Tail recursive.... but no mutation is going on. Why?
   84|  8.79k|      return variant_reader<Archive, Variant, TNext, TEnd>::read(ar, v, t);
   85|  8.79k|    }
   86|  9.36k|    return true;
   87|  18.4k|  }
_ZN14variant_readerI14binary_archiveILb0EEN5boost7variantIN10cryptonote15txout_to_scriptEJNS4_19txout_to_scripthashENS4_12txout_to_keyENS4_19txout_to_tagged_keyEEEENS2_3mpl6l_iterINSA_6l_itemIN4mpl_5long_ILl3EEES6_NSC_INSE_ILl2EEES7_NSC_INSE_ILl1EEES8_NSA_5l_endEEEEEEEEENSB_ISI_EEE4readERS1_RS9_h:
   73|  8.79k|  {
   74|  8.79k|    if(variant_serialization_traits<Archive, current_type>::get_tag() == t) {
  ------------------
  |  Branch (74:8): [True: 3.43k, False: 5.36k]
  ------------------
   75|  3.43k|      current_type x;
   76|  3.43k|      if(!do_serialize(ar, x))
  ------------------
  |  Branch (76:10): [True: 0, False: 3.43k]
  ------------------
   77|      0|      {
   78|      0|        ar.set_fail();
   79|      0|        return false;
   80|      0|      }
   81|  3.43k|      v = x;
   82|  5.36k|    } else {
   83|       |      // Tail recursive.... but no mutation is going on. Why?
   84|  5.36k|      return variant_reader<Archive, Variant, TNext, TEnd>::read(ar, v, t);
   85|  5.36k|    }
   86|  3.43k|    return true;
   87|  8.79k|  }
_ZN14variant_readerI14binary_archiveILb0EEN5boost7variantIN10cryptonote15txout_to_scriptEJNS4_19txout_to_scripthashENS4_12txout_to_keyENS4_19txout_to_tagged_keyEEEENS2_3mpl6l_iterINSA_6l_itemIN4mpl_5long_ILl2EEES7_NSC_INSE_ILl1EEES8_NSA_5l_endEEEEEEENSB_ISH_EEE4readERS1_RS9_h:
   73|  5.36k|  {
   74|  5.36k|    if(variant_serialization_traits<Archive, current_type>::get_tag() == t) {
  ------------------
  |  Branch (74:8): [True: 4.92k, False: 439]
  ------------------
   75|  4.92k|      current_type x;
   76|  4.92k|      if(!do_serialize(ar, x))
  ------------------
  |  Branch (76:10): [True: 0, False: 4.92k]
  ------------------
   77|      0|      {
   78|      0|        ar.set_fail();
   79|      0|        return false;
   80|      0|      }
   81|  4.92k|      v = x;
   82|  4.92k|    } else {
   83|       |      // Tail recursive.... but no mutation is going on. Why?
   84|    439|      return variant_reader<Archive, Variant, TNext, TEnd>::read(ar, v, t);
   85|    439|    }
   86|  4.92k|    return true;
   87|  5.36k|  }
_ZN14variant_readerI14binary_archiveILb0EEN5boost7variantIN10cryptonote15txout_to_scriptEJNS4_19txout_to_scripthashENS4_12txout_to_keyENS4_19txout_to_tagged_keyEEEENS2_3mpl6l_iterINSA_6l_itemIN4mpl_5long_ILl1EEES8_NSA_5l_endEEEEENSB_ISG_EEE4readERS1_RS9_h:
   73|    439|  {
   74|    439|    if(variant_serialization_traits<Archive, current_type>::get_tag() == t) {
  ------------------
  |  Branch (74:8): [True: 397, False: 42]
  ------------------
   75|    397|      current_type x;
   76|    397|      if(!do_serialize(ar, x))
  ------------------
  |  Branch (76:10): [True: 10, False: 387]
  ------------------
   77|     10|      {
   78|     10|        ar.set_fail();
   79|     10|        return false;
   80|     10|      }
   81|    387|      v = x;
   82|    387|    } else {
   83|       |      // Tail recursive.... but no mutation is going on. Why?
   84|     42|      return variant_reader<Archive, Variant, TNext, TEnd>::read(ar, v, t);
   85|     42|    }
   86|    387|    return true;
   87|    439|  }
_ZN14variant_readerI14binary_archiveILb0EEN5boost7variantIN10cryptonote15txout_to_scriptEJNS4_19txout_to_scripthashENS4_12txout_to_keyENS4_19txout_to_tagged_keyEEEENS2_3mpl6l_iterINSA_5l_endEEESD_E4readERS1_RS9_h:
   98|     42|  {
   99|     42|    ar.set_fail();
  100|     42|    return false;
  101|     42|  }
wallet2.cpp:_ZL12do_serializeI14binary_archiveJN10cryptonote8txin_genENS1_14txin_to_scriptENS1_18txin_to_scripthashENS1_11txin_to_keyEEEbRT_ILb1EERN5boost7variantIDpT0_EE:
  145|     92|{
  146|     92|  return boost::apply_visitor(variant_write_visitor<Archive>(ar), v);
  147|     92|}
_ZNK21variant_write_visitorI14binary_archiveEclIN10cryptonote8txin_genEEEbRT_:
  130|     18|    {
  131|     18|      ar.begin_variant();
  132|     18|      ar.write_variant_tag(variant_serialization_traits<Archive<true>, T>::get_tag());
  133|     18|      if(!do_serialize(ar, rv))
  ------------------
  |  Branch (133:10): [True: 0, False: 18]
  ------------------
  134|      0|      {
  135|      0|        ar.set_fail();
  136|      0|        return false;
  137|      0|      }
  138|     18|      ar.end_variant();
  139|     18|      return true;
  140|     18|    }
_ZNK21variant_write_visitorI14binary_archiveEclIN10cryptonote14txin_to_scriptEEEbRT_:
  130|     50|    {
  131|     50|      ar.begin_variant();
  132|     50|      ar.write_variant_tag(variant_serialization_traits<Archive<true>, T>::get_tag());
  133|     50|      if(!do_serialize(ar, rv))
  ------------------
  |  Branch (133:10): [True: 0, False: 50]
  ------------------
  134|      0|      {
  135|      0|        ar.set_fail();
  136|      0|        return false;
  137|      0|      }
  138|     50|      ar.end_variant();
  139|     50|      return true;
  140|     50|    }
_ZNK21variant_write_visitorI14binary_archiveEclIN10cryptonote11txin_to_keyEEEbRT_:
  130|     24|    {
  131|     24|      ar.begin_variant();
  132|     24|      ar.write_variant_tag(variant_serialization_traits<Archive<true>, T>::get_tag());
  133|     24|      if(!do_serialize(ar, rv))
  ------------------
  |  Branch (133:10): [True: 0, False: 24]
  ------------------
  134|      0|      {
  135|      0|        ar.set_fail();
  136|      0|        return false;
  137|      0|      }
  138|     24|      ar.end_variant();
  139|     24|      return true;
  140|     24|    }
_ZN21variant_write_visitorI14binary_archiveEC2ERS0_ILb1EE:
  126|  1.96k|    variant_write_visitor(Archive<true> &a) : ar(a) { }
wallet2.cpp:_ZL12do_serializeI14binary_archiveJN10cryptonote15txout_to_scriptENS1_19txout_to_scripthashENS1_12txout_to_keyENS1_19txout_to_tagged_keyEEEbRT_ILb1EERN5boost7variantIDpT0_EE:
  145|     71|{
  146|     71|  return boost::apply_visitor(variant_write_visitor<Archive>(ar), v);
  147|     71|}
_ZNK21variant_write_visitorI14binary_archiveEclIN10cryptonote15txout_to_scriptEEEbRT_:
  130|     43|    {
  131|     43|      ar.begin_variant();
  132|     43|      ar.write_variant_tag(variant_serialization_traits<Archive<true>, T>::get_tag());
  133|     43|      if(!do_serialize(ar, rv))
  ------------------
  |  Branch (133:10): [True: 0, False: 43]
  ------------------
  134|      0|      {
  135|      0|        ar.set_fail();
  136|      0|        return false;
  137|      0|      }
  138|     43|      ar.end_variant();
  139|     43|      return true;
  140|     43|    }
_ZNK21variant_write_visitorI14binary_archiveEclIN10cryptonote19txout_to_scripthashEEEbRT_:
  130|      1|    {
  131|      1|      ar.begin_variant();
  132|      1|      ar.write_variant_tag(variant_serialization_traits<Archive<true>, T>::get_tag());
  133|      1|      if(!do_serialize(ar, rv))
  ------------------
  |  Branch (133:10): [True: 0, False: 1]
  ------------------
  134|      0|      {
  135|      0|        ar.set_fail();
  136|      0|        return false;
  137|      0|      }
  138|      1|      ar.end_variant();
  139|      1|      return true;
  140|      1|    }
_ZNK21variant_write_visitorI14binary_archiveEclIN10cryptonote12txout_to_keyEEEbRT_:
  130|     23|    {
  131|     23|      ar.begin_variant();
  132|     23|      ar.write_variant_tag(variant_serialization_traits<Archive<true>, T>::get_tag());
  133|     23|      if(!do_serialize(ar, rv))
  ------------------
  |  Branch (133:10): [True: 0, False: 23]
  ------------------
  134|      0|      {
  135|      0|        ar.set_fail();
  136|      0|        return false;
  137|      0|      }
  138|     23|      ar.end_variant();
  139|     23|      return true;
  140|     23|    }
_ZNK21variant_write_visitorI14binary_archiveEclIN10cryptonote19txout_to_tagged_keyEEEbRT_:
  130|      4|    {
  131|      4|      ar.begin_variant();
  132|      4|      ar.write_variant_tag(variant_serialization_traits<Archive<true>, T>::get_tag());
  133|      4|      if(!do_serialize(ar, rv))
  ------------------
  |  Branch (133:10): [True: 0, False: 4]
  ------------------
  134|      0|      {
  135|      0|        ar.set_fail();
  136|      0|        return false;
  137|      0|      }
  138|      4|      ar.end_variant();
  139|      4|      return true;
  140|      4|    }
cryptonote_format_utils.cpp:_ZL12do_serializeI14binary_archiveJN10cryptonote16tx_extra_paddingENS1_16tx_extra_pub_keyENS1_14tx_extra_nonceENS1_25tx_extra_merge_mining_tagENS1_28tx_extra_additional_pub_keysENS1_29tx_extra_mysterious_minergateEEEbRT_ILb0EERN5boost7variantIDpT0_EE:
  105|  21.8k|static bool do_serialize(Archive<false> &ar, boost::variant<T...> &v) {
  106|  21.8k|    using types = typename boost::variant<T...>::types;
  107|  21.8k|    typename Archive<false>::variant_tag_type t;
  108|  21.8k|    ar.begin_variant();
  109|  21.8k|    ar.read_variant_tag(t);
  110|  21.8k|    if(!variant_reader<Archive<false>, boost::variant<T...>,
  ------------------
  |  Branch (110:8): [True: 590, False: 21.2k]
  ------------------
  111|  21.8k|       typename boost::mpl::begin<types>::type,
  112|  21.8k|       typename boost::mpl::end<types>::type>::read(ar, v, t))
  113|    590|    {
  114|    590|      ar.set_fail();
  115|    590|      return false;
  116|    590|    }
  117|  21.2k|    ar.end_variant();
  118|  21.2k|    return true;
  119|  21.8k|}
_ZN14variant_readerI14binary_archiveILb0EEN5boost7variantIN10cryptonote16tx_extra_paddingEJNS4_16tx_extra_pub_keyENS4_14tx_extra_nonceENS4_25tx_extra_merge_mining_tagENS4_28tx_extra_additional_pub_keysENS4_29tx_extra_mysterious_minergateEEEENS2_3mpl6l_iterINSC_6l_itemIN4mpl_5long_ILl6EEES5_NSE_INSG_ILl5EEES6_NSE_INSG_ILl4EEES7_NSE_INSG_ILl3EEES8_NSE_INSG_ILl2EEES9_NSE_INSG_ILl1EEESA_NSC_5l_endEEEEEEEEEEEEEEENSD_ISN_EEE4readERS1_RSB_h:
   73|  21.8k|  {
   74|  21.8k|    if(variant_serialization_traits<Archive, current_type>::get_tag() == t) {
  ------------------
  |  Branch (74:8): [True: 557, False: 21.3k]
  ------------------
   75|    557|      current_type x;
   76|    557|      if(!do_serialize(ar, x))
  ------------------
  |  Branch (76:10): [True: 162, False: 395]
  ------------------
   77|    162|      {
   78|    162|        ar.set_fail();
   79|    162|        return false;
   80|    162|      }
   81|    395|      v = x;
   82|  21.3k|    } else {
   83|       |      // Tail recursive.... but no mutation is going on. Why?
   84|  21.3k|      return variant_reader<Archive, Variant, TNext, TEnd>::read(ar, v, t);
   85|  21.3k|    }
   86|    395|    return true;
   87|  21.8k|  }
_ZN14variant_readerI14binary_archiveILb0EEN5boost7variantIN10cryptonote16tx_extra_paddingEJNS4_16tx_extra_pub_keyENS4_14tx_extra_nonceENS4_25tx_extra_merge_mining_tagENS4_28tx_extra_additional_pub_keysENS4_29tx_extra_mysterious_minergateEEEENS2_3mpl6l_iterINSC_6l_itemIN4mpl_5long_ILl5EEES6_NSE_INSG_ILl4EEES7_NSE_INSG_ILl3EEES8_NSE_INSG_ILl2EEES9_NSE_INSG_ILl1EEESA_NSC_5l_endEEEEEEEEEEEEENSD_ISM_EEE4readERS1_RSB_h:
   73|  21.3k|  {
   74|  21.3k|    if(variant_serialization_traits<Archive, current_type>::get_tag() == t) {
  ------------------
  |  Branch (74:8): [True: 5.07k, False: 16.2k]
  ------------------
   75|  5.07k|      current_type x;
   76|  5.07k|      if(!do_serialize(ar, x))
  ------------------
  |  Branch (76:10): [True: 41, False: 5.03k]
  ------------------
   77|     41|      {
   78|     41|        ar.set_fail();
   79|     41|        return false;
   80|     41|      }
   81|  5.03k|      v = x;
   82|  16.2k|    } else {
   83|       |      // Tail recursive.... but no mutation is going on. Why?
   84|  16.2k|      return variant_reader<Archive, Variant, TNext, TEnd>::read(ar, v, t);
   85|  16.2k|    }
   86|  5.03k|    return true;
   87|  21.3k|  }
_ZN14variant_readerI14binary_archiveILb0EEN5boost7variantIN10cryptonote16tx_extra_paddingEJNS4_16tx_extra_pub_keyENS4_14tx_extra_nonceENS4_25tx_extra_merge_mining_tagENS4_28tx_extra_additional_pub_keysENS4_29tx_extra_mysterious_minergateEEEENS2_3mpl6l_iterINSC_6l_itemIN4mpl_5long_ILl4EEES7_NSE_INSG_ILl3EEES8_NSE_INSG_ILl2EEES9_NSE_INSG_ILl1EEESA_NSC_5l_endEEEEEEEEEEENSD_ISL_EEE4readERS1_RSB_h:
   73|  16.2k|  {
   74|  16.2k|    if(variant_serialization_traits<Archive, current_type>::get_tag() == t) {
  ------------------
  |  Branch (74:8): [True: 11.5k, False: 4.71k]
  ------------------
   75|  11.5k|      current_type x;
   76|  11.5k|      if(!do_serialize(ar, x))
  ------------------
  |  Branch (76:10): [True: 42, False: 11.4k]
  ------------------
   77|     42|      {
   78|     42|        ar.set_fail();
   79|     42|        return false;
   80|     42|      }
   81|  11.4k|      v = x;
   82|  11.4k|    } else {
   83|       |      // Tail recursive.... but no mutation is going on. Why?
   84|  4.71k|      return variant_reader<Archive, Variant, TNext, TEnd>::read(ar, v, t);
   85|  4.71k|    }
   86|  11.4k|    return true;
   87|  16.2k|  }
_ZN14variant_readerI14binary_archiveILb0EEN5boost7variantIN10cryptonote16tx_extra_paddingEJNS4_16tx_extra_pub_keyENS4_14tx_extra_nonceENS4_25tx_extra_merge_mining_tagENS4_28tx_extra_additional_pub_keysENS4_29tx_extra_mysterious_minergateEEEENS2_3mpl6l_iterINSC_6l_itemIN4mpl_5long_ILl3EEES8_NSE_INSG_ILl2EEES9_NSE_INSG_ILl1EEESA_NSC_5l_endEEEEEEEEENSD_ISK_EEE4readERS1_RSB_h:
   73|  4.71k|  {
   74|  4.71k|    if(variant_serialization_traits<Archive, current_type>::get_tag() == t) {
  ------------------
  |  Branch (74:8): [True: 143, False: 4.57k]
  ------------------
   75|    143|      current_type x;
   76|    143|      if(!do_serialize(ar, x))
  ------------------
  |  Branch (76:10): [True: 50, False: 93]
  ------------------
   77|     50|      {
   78|     50|        ar.set_fail();
   79|     50|        return false;
   80|     50|      }
   81|     93|      v = x;
   82|  4.57k|    } else {
   83|       |      // Tail recursive.... but no mutation is going on. Why?
   84|  4.57k|      return variant_reader<Archive, Variant, TNext, TEnd>::read(ar, v, t);
   85|  4.57k|    }
   86|     93|    return true;
   87|  4.71k|  }
_ZN14variant_readerI14binary_archiveILb0EEN5boost7variantIN10cryptonote16tx_extra_paddingEJNS4_16tx_extra_pub_keyENS4_14tx_extra_nonceENS4_25tx_extra_merge_mining_tagENS4_28tx_extra_additional_pub_keysENS4_29tx_extra_mysterious_minergateEEEENS2_3mpl6l_iterINSC_6l_itemIN4mpl_5long_ILl2EEES9_NSE_INSG_ILl1EEESA_NSC_5l_endEEEEEEENSD_ISJ_EEE4readERS1_RSB_h:
   73|  4.57k|  {
   74|  4.57k|    if(variant_serialization_traits<Archive, current_type>::get_tag() == t) {
  ------------------
  |  Branch (74:8): [True: 1.41k, False: 3.16k]
  ------------------
   75|  1.41k|      current_type x;
   76|  1.41k|      if(!do_serialize(ar, x))
  ------------------
  |  Branch (76:10): [True: 28, False: 1.38k]
  ------------------
   77|     28|      {
   78|     28|        ar.set_fail();
   79|     28|        return false;
   80|     28|      }
   81|  1.38k|      v = x;
   82|  3.16k|    } else {
   83|       |      // Tail recursive.... but no mutation is going on. Why?
   84|  3.16k|      return variant_reader<Archive, Variant, TNext, TEnd>::read(ar, v, t);
   85|  3.16k|    }
   86|  1.38k|    return true;
   87|  4.57k|  }
_ZN14variant_readerI14binary_archiveILb0EEN5boost7variantIN10cryptonote16tx_extra_paddingEJNS4_16tx_extra_pub_keyENS4_14tx_extra_nonceENS4_25tx_extra_merge_mining_tagENS4_28tx_extra_additional_pub_keysENS4_29tx_extra_mysterious_minergateEEEENS2_3mpl6l_iterINSC_6l_itemIN4mpl_5long_ILl1EEESA_NSC_5l_endEEEEENSD_ISI_EEE4readERS1_RSB_h:
   73|  3.16k|  {
   74|  3.16k|    if(variant_serialization_traits<Archive, current_type>::get_tag() == t) {
  ------------------
  |  Branch (74:8): [True: 2.91k, False: 245]
  ------------------
   75|  2.91k|      current_type x;
   76|  2.91k|      if(!do_serialize(ar, x))
  ------------------
  |  Branch (76:10): [True: 22, False: 2.89k]
  ------------------
   77|     22|      {
   78|     22|        ar.set_fail();
   79|     22|        return false;
   80|     22|      }
   81|  2.89k|      v = x;
   82|  2.89k|    } else {
   83|       |      // Tail recursive.... but no mutation is going on. Why?
   84|    245|      return variant_reader<Archive, Variant, TNext, TEnd>::read(ar, v, t);
   85|    245|    }
   86|  2.89k|    return true;
   87|  3.16k|  }
_ZN14variant_readerI14binary_archiveILb0EEN5boost7variantIN10cryptonote16tx_extra_paddingEJNS4_16tx_extra_pub_keyENS4_14tx_extra_nonceENS4_25tx_extra_merge_mining_tagENS4_28tx_extra_additional_pub_keysENS4_29tx_extra_mysterious_minergateEEEENS2_3mpl6l_iterINSC_5l_endEEESF_E4readERS1_RSB_h:
   98|    245|  {
   99|    245|    ar.set_fail();
  100|    245|    return false;
  101|    245|  }
cryptonote_format_utils.cpp:_ZL12do_serializeI14binary_archiveJN10cryptonote16tx_extra_paddingENS1_16tx_extra_pub_keyENS1_14tx_extra_nonceENS1_25tx_extra_merge_mining_tagENS1_28tx_extra_additional_pub_keysENS1_29tx_extra_mysterious_minergateEEEbRT_ILb1EERN5boost7variantIDpT0_EE:
  145|  1.79k|{
  146|  1.79k|  return boost::apply_visitor(variant_write_visitor<Archive>(ar), v);
  147|  1.79k|}
_ZNK21variant_write_visitorI14binary_archiveEclIN10cryptonote16tx_extra_paddingEEEbRT_:
  130|     89|    {
  131|     89|      ar.begin_variant();
  132|     89|      ar.write_variant_tag(variant_serialization_traits<Archive<true>, T>::get_tag());
  133|     89|      if(!do_serialize(ar, rv))
  ------------------
  |  Branch (133:10): [True: 0, False: 89]
  ------------------
  134|      0|      {
  135|      0|        ar.set_fail();
  136|      0|        return false;
  137|      0|      }
  138|     89|      ar.end_variant();
  139|     89|      return true;
  140|     89|    }
_ZNK21variant_write_visitorI14binary_archiveEclIN10cryptonote16tx_extra_pub_keyEEEbRT_:
  130|    453|    {
  131|    453|      ar.begin_variant();
  132|    453|      ar.write_variant_tag(variant_serialization_traits<Archive<true>, T>::get_tag());
  133|    453|      if(!do_serialize(ar, rv))
  ------------------
  |  Branch (133:10): [True: 0, False: 453]
  ------------------
  134|      0|      {
  135|      0|        ar.set_fail();
  136|      0|        return false;
  137|      0|      }
  138|    453|      ar.end_variant();
  139|    453|      return true;
  140|    453|    }
_ZNK21variant_write_visitorI14binary_archiveEclIN10cryptonote25tx_extra_merge_mining_tagEEEbRT_:
  130|     32|    {
  131|     32|      ar.begin_variant();
  132|     32|      ar.write_variant_tag(variant_serialization_traits<Archive<true>, T>::get_tag());
  133|     32|      if(!do_serialize(ar, rv))
  ------------------
  |  Branch (133:10): [True: 0, False: 32]
  ------------------
  134|      0|      {
  135|      0|        ar.set_fail();
  136|      0|        return false;
  137|      0|      }
  138|     32|      ar.end_variant();
  139|     32|      return true;
  140|     32|    }
_ZNK21variant_write_visitorI14binary_archiveEclIN10cryptonote28tx_extra_additional_pub_keysEEEbRT_:
  130|    266|    {
  131|    266|      ar.begin_variant();
  132|    266|      ar.write_variant_tag(variant_serialization_traits<Archive<true>, T>::get_tag());
  133|    266|      if(!do_serialize(ar, rv))
  ------------------
  |  Branch (133:10): [True: 0, False: 266]
  ------------------
  134|      0|      {
  135|      0|        ar.set_fail();
  136|      0|        return false;
  137|      0|      }
  138|    266|      ar.end_variant();
  139|    266|      return true;
  140|    266|    }
_ZNK21variant_write_visitorI14binary_archiveEclIN10cryptonote29tx_extra_mysterious_minergateEEEbRT_:
  130|    957|    {
  131|    957|      ar.begin_variant();
  132|    957|      ar.write_variant_tag(variant_serialization_traits<Archive<true>, T>::get_tag());
  133|    957|      if(!do_serialize(ar, rv))
  ------------------
  |  Branch (133:10): [True: 0, False: 957]
  ------------------
  134|      0|      {
  135|      0|        ar.set_fail();
  136|      0|        return false;
  137|      0|      }
  138|    957|      ar.end_variant();
  139|    957|      return true;
  140|    957|    }

_ZN3mms13message_storeC2ENSt3__110unique_ptrIN4epee9net_utils4http20abstract_http_clientENS1_14default_deleteIS6_EEEE:
   54|      1|message_store::message_store(std::unique_ptr<epee::net_utils::http::abstract_http_client> http_client) : m_transporter(std::move(http_client))
   55|      1|{
   56|      1|  m_active = false;
   57|      1|  m_auto_send = false;
   58|      1|  m_next_message_id = 1;
   59|      1|  m_num_authorized_signers = 0;
   60|      1|  m_num_required_signers = 0;
   61|      1|  m_nettype = cryptonote::network_type::UNDEFINED;
   62|      1|  m_run = true;
   63|      1|}

_ZN3mms19message_transporterC2ENSt3__110unique_ptrIN4epee9net_utils4http20abstract_http_clientENS1_14default_deleteIS6_EEEE:
   84|      1|message_transporter::message_transporter(std::unique_ptr<epee::net_utils::http::abstract_http_client> http_client) : m_http_client(std::move(http_client))
   85|      1|{
   86|      1|  m_run = true;
   87|      1|}

_ZN5tools12NodeRPCProxyC2ERN4epee9net_utils4http20abstract_http_clientERN5boost15recursive_mutexE:
   54|      1|  : m_http_client(http_client)
   55|      1|  , m_daemon_rpc_mutex(mutex)
   56|      1|  , m_offline(false)
   57|      1|{
   58|      1|  invalidate();
   59|      1|}
_ZN5tools12NodeRPCProxy10invalidateEv:
   62|      2|{
   63|      2|  m_height = 0;
   64|    514|  for (size_t n = 0; n < 256; ++n)
  ------------------
  |  Branch (64:22): [True: 512, False: 2]
  ------------------
   65|    512|    m_earliest_height[n] = 0;
   66|      2|  m_dynamic_base_fee_estimate = 0;
   67|      2|  m_dynamic_base_fee_estimate_cached_height = 0;
   68|      2|  m_dynamic_base_fee_estimate_grace_blocks = 0;
   69|      2|  m_dynamic_base_fee_estimate_vector.clear();
   70|      2|  m_fee_quantization_mask = 1;
   71|      2|  m_rpc_version = 0;
   72|      2|  m_target_height = 0;
   73|      2|  m_block_weight_limit = 0;
   74|      2|  m_adjusted_time = 0;
   75|      2|  m_get_info_time = 0;
   76|      2|  m_height_time = 0;
   77|      2|  m_target_height_time = 0;
   78|      2|  m_daemon_hard_forks.clear();
   79|      2|}

_ZN5tools7wallet22trEPKc:
 1031|      1|const char* wallet2::tr(const char* str) { return i18n_translate(str, "tools::wallet2"); }
_ZN5tools7wallet2C2EN10cryptonote12network_typeEmbNSt3__110unique_ptrIN4epee9net_utils4http19http_client_factoryENS3_14default_deleteIS8_EEEE:
 1188|      1|  m_http_client(http_client_factory->create()),
 1189|       |  m_multisig_rescan_info(NULL),
 1190|       |  m_multisig_rescan_k(NULL),
 1191|      1|  m_upper_transaction_weight_limit(0),
 1192|      1|  m_run(true),
 1193|      1|  m_callback(0),
 1194|      1|  m_trusted_daemon(false),
 1195|      1|  m_nettype(nettype),
 1196|      1|  m_multisig_rounds_passed(0),
 1197|      1|  m_always_confirm_transfers(true),
 1198|      1|  m_print_ring_members(false),
 1199|      1|  m_store_tx_info(true),
 1200|      1|  m_default_mixin(0),
 1201|      1|  m_default_priority(0),
 1202|      1|  m_refresh_type(RefreshOptimizeCoinbase),
 1203|      1|  m_auto_refresh(true),
 1204|      1|  m_first_refresh_done(false),
 1205|      1|  m_refresh_from_block_height(0),
 1206|      1|  m_explicit_refresh_from_block_height(true),
 1207|      1|  m_skip_to_height(0),
 1208|      1|  m_ask_password(AskPasswordToDecrypt),
 1209|      1|  m_max_reorg_depth(ORPHANED_BLOCKS_MAX_COUNT),
  ------------------
  |  |   77|      1|#define ORPHANED_BLOCKS_MAX_COUNT                       100
  ------------------
 1210|      1|  m_min_output_count(0),
 1211|      1|  m_min_output_value(0),
 1212|      1|  m_merge_destinations(false),
 1213|      1|  m_confirm_backlog(true),
 1214|      1|  m_confirm_backlog_threshold(0),
 1215|      1|  m_confirm_export_overwrite(true),
 1216|      1|  m_auto_low_priority(true),
 1217|      1|  m_segregate_pre_fork_outputs(true),
 1218|      1|  m_key_reuse_mitigation2(true),
 1219|      1|  m_segregation_height(0),
 1220|      1|  m_ignore_fractional_outputs(true),
 1221|      1|  m_ignore_outputs_above(MONEY_SUPPLY),
  ------------------
  |  |   54|      1|#define MONEY_SUPPLY                                    ((uint64_t)(-1))
  ------------------
 1222|      1|  m_ignore_outputs_below(0),
 1223|      1|  m_track_uses(false),
 1224|      1|  m_is_background_wallet(false),
 1225|      1|  m_background_sync_type(BackgroundSyncOff),
 1226|      1|  m_background_syncing(false),
 1227|      1|  m_processing_background_cache(false),
 1228|      1|  m_custom_background_key(boost::none),
 1229|      1|  m_show_wallet_name_when_locked(false),
 1230|      1|  m_inactivity_lock_timeout(DEFAULT_INACTIVITY_LOCK_TIMEOUT),
  ------------------
  |  |  148|      1|#define DEFAULT_INACTIVITY_LOCK_TIMEOUT 90 // a minute and a half
  ------------------
 1231|      1|  m_setup_background_mining(BackgroundMiningMaybe),
 1232|      1|  m_is_initialized(false),
 1233|      1|  m_kdf_rounds(kdf_rounds),
 1234|      1|  is_old_file_format(false),
 1235|      1|  m_watch_only(false),
 1236|      1|  m_multisig(false),
 1237|      1|  m_multisig_threshold(0),
 1238|      1|  m_node_rpc_proxy(*m_http_client, m_daemon_rpc_mutex),
 1239|      1|  m_account_public_address{crypto::null_pkey, crypto::null_pkey},
 1240|      1|  m_subaddress_lookahead_major(SUBADDRESS_LOOKAHEAD_MAJOR),
  ------------------
  |  |  126|      1|#define SUBADDRESS_LOOKAHEAD_MAJOR 50
  ------------------
 1241|      1|  m_subaddress_lookahead_minor(SUBADDRESS_LOOKAHEAD_MINOR),
  ------------------
  |  |  127|      1|#define SUBADDRESS_LOOKAHEAD_MINOR 200
  ------------------
 1242|      1|  m_original_keys_available(false),
 1243|      1|  m_message_store(http_client_factory->create()),
 1244|      1|  m_key_device_type(hw::device::device_type::SOFTWARE),
 1245|      1|  m_ring_history_saved(false),
 1246|      1|  m_ringdb(),
 1247|      1|  m_last_block_reward(0),
 1248|      1|  m_unattended(unattended),
 1249|      1|  m_devices_registered(false),
 1250|      1|  m_device_last_key_image_sync(0),
 1251|      1|  m_use_dns(true),
 1252|      1|  m_offline(false),
 1253|      1|  m_rpc_version(0),
 1254|      1|  m_export_format(ExportFormat::Binary),
 1255|      1|  m_load_deprecated_formats(false),
 1256|      1|  m_enable_multisig(false),
 1257|      1|  m_pool_info_query_time(0),
 1258|      1|  m_has_ever_refreshed_from_node(false),
 1259|      1|  m_allow_mismatched_daemon_version(false)
 1260|      1|{
 1261|      1|}
_ZN5tools7wallet2D2Ev:
 1264|      1|{
 1265|      1|  deinit();
 1266|      1|}
_ZN5tools7wallet210set_daemonENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN5boost8optionalIN4epee9net_utils4http5loginEEEbNSB_13ssl_options_tERKS7_:
 1368|      1|{
 1369|      1|  boost::lock_guard<boost::recursive_mutex> lock(m_daemon_rpc_mutex);
 1370|       |
 1371|      1|  if(daemon_address.empty()) {
  ------------------
  |  Branch (1371:6): [True: 1, False: 0]
  ------------------
 1372|      1|    daemon_address.append("http://localhost:" + std::to_string(get_config(m_nettype).RPC_DEFAULT_PORT));
 1373|      1|  }
 1374|       |
 1375|      1|  if(m_http_client->is_connected())
  ------------------
  |  Branch (1375:6): [True: 0, False: 1]
  ------------------
 1376|      0|    m_http_client->disconnect();
 1377|      1|  CHECK_AND_ASSERT_MES2(m_proxy.empty() || proxy.empty() , "It is not possible to set global proxy (--proxy) and daemon specific proxy together.");
  ------------------
  |  |  205|      1|#define CHECK_AND_ASSERT_MES2(expr, message)   do{if(!(expr)) {LOG_ERROR(message); };}while(0)
  |  |  ------------------
  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (205:56): [True: 1, False: 0]
  |  |  |  Branch (205:56): [True: 0, False: 0]
  |  |  |  Branch (205:93): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1378|      1|  if(m_proxy.empty())
  ------------------
  |  Branch (1378:6): [True: 1, False: 0]
  ------------------
 1379|      1|    CHECK_AND_ASSERT_MES(set_proxy(proxy), false, "failed to set proxy address");
  ------------------
  |  |  183|      1|#define CHECK_AND_ASSERT_MES(expr, fail_ret_val, message)   do{if(!(expr)) {LOG_ERROR(message); return fail_ret_val;};}while(0)
  |  |  ------------------
  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (183:67): [True: 0, False: 1]
  |  |  |  Branch (183:126): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1380|      1|  const bool changed = m_daemon_address != daemon_address;
 1381|      1|  m_daemon_address = std::move(daemon_address);
 1382|      1|  m_daemon_login = std::move(daemon_login);
 1383|      1|  m_trusted_daemon = trusted_daemon;
 1384|      1|  if (changed)
  ------------------
  |  Branch (1384:7): [True: 1, False: 0]
  ------------------
 1385|      1|  {
 1386|      1|    m_rpc_version = 0;
 1387|      1|    m_node_rpc_proxy.invalidate();
 1388|      1|    m_pool_info_query_time = 0;
 1389|      1|  }
 1390|       |
 1391|      1|  const std::string address = get_daemon_address();
 1392|      1|  MINFO("setting daemon to " << address);
  ------------------
  |  |   77|      1|#define MINFO(x) MCINFO(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  ------------------
  |  |  |  |   55|      1|#define MCINFO(cat,x) MCLOG(el::Level::Info,cat, el::Color::Default, x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      1|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   43|      1|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |   44|      1|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 1]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |   47|      1|  } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1393|      1|  bool ret =  m_http_client->set_server(address, get_daemon_login(), std::move(ssl_options));
 1394|      1|  if (ret)
  ------------------
  |  Branch (1394:7): [True: 1, False: 0]
  ------------------
 1395|      1|  {
 1396|      1|    CRITICAL_REGION_LOCAL(default_daemon_address_lock);
  ------------------
  |  |  153|      1|#define  CRITICAL_REGION_LOCAL(x) {} epee::critical_region_t<decltype(x)>   critical_region_var(x)
  ------------------
 1397|      1|    default_daemon_address = address;
 1398|      1|  }
 1399|      1|  return ret;
 1400|      1|}
_ZN5tools7wallet29set_proxyERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 1403|      2|{
 1404|      2|  return m_http_client->set_proxy(address);
 1405|      2|}
_ZN5tools7wallet24initENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN5boost8optionalIN4epee9net_utils4http5loginEEERKS7_mbNSB_13ssl_options_tE:
 1408|      1|{
 1409|      1|  m_proxy = proxy_address;
 1410|      1|  CHECK_AND_ASSERT_MES(set_proxy(m_proxy), false, "failed to set proxy address");
  ------------------
  |  |  183|      1|#define CHECK_AND_ASSERT_MES(expr, fail_ret_val, message)   do{if(!(expr)) {LOG_ERROR(message); return fail_ret_val;};}while(0)
  |  |  ------------------
  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (183:67): [True: 0, False: 1]
  |  |  |  Branch (183:126): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1411|      1|  m_checkpoints.init_default_checkpoints(m_nettype);
 1412|      1|  m_is_initialized = true;
 1413|      1|  m_upper_transaction_weight_limit = upper_transaction_weight_limit;
 1414|      1|  return set_daemon(daemon_address, daemon_login, trusted_daemon, std::move(ssl_options));
 1415|      1|}
_ZNK5tools7wallet231get_subaddress_spend_public_keyERKN10cryptonote16subaddress_indexE:
 1557|    711|{
 1558|    711|  hw::device &hwdev = m_account.get_device();
 1559|    711|  return hwdev.get_subaddress_spend_public_key(m_account.get_keys(), index);
 1560|    711|}
_ZN5tools7wallet222add_subaddress_accountERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 1574|      1|{
 1575|      1|  uint32_t index_major = (uint32_t)get_num_subaddress_accounts();
 1576|      1|  expand_subaddresses({index_major, 0});
 1577|      1|  m_subaddress_labels[index_major][0] = label;
 1578|      1|}
_ZNK5tools7wallet213should_expandERKN10cryptonote16subaddress_indexE:
 1589|  1.03k|{
 1590|  1.03k|  const uint32_t last_major = m_subaddress_labels.size() - 1 > (std::numeric_limits<uint32_t>::max() - m_subaddress_lookahead_major) ? std::numeric_limits<uint32_t>::max()  : (m_subaddress_labels.size() + m_subaddress_lookahead_major - 1);
  ------------------
  |  Branch (1590:31): [True: 0, False: 1.03k]
  ------------------
 1591|  1.03k|  if (index.major > last_major)
  ------------------
  |  Branch (1591:7): [True: 173, False: 865]
  ------------------
 1592|    173|    return false;
 1593|    865|  const size_t nsub = index.major < m_subaddress_labels.size() ? m_subaddress_labels[index.major].size() : 0;
  ------------------
  |  Branch (1593:23): [True: 595, False: 270]
  ------------------
 1594|    865|  const uint32_t last_minor = nsub - 1 > (std::numeric_limits<uint32_t>::max() - m_subaddress_lookahead_minor) ? std::numeric_limits<uint32_t>::max()  : (nsub + m_subaddress_lookahead_minor - 1);
  ------------------
  |  Branch (1594:31): [True: 270, False: 595]
  ------------------
 1595|    865|  if (index.minor > last_minor)
  ------------------
  |  Branch (1595:7): [True: 154, False: 711]
  ------------------
 1596|    154|    return false;
 1597|    711|  return true;
 1598|    865|}
_ZN5tools7wallet219expand_subaddressesERKN10cryptonote16subaddress_indexE:
 1601|      1|{
 1602|      1|  hw::device &hwdev = m_account.get_device();
 1603|      1|  if (m_subaddress_labels.size() <= index.major)
  ------------------
  |  Branch (1603:7): [True: 1, False: 0]
  ------------------
 1604|      1|  {
 1605|       |    // add new accounts
 1606|      1|    cryptonote::subaddress_index index2;
 1607|      1|    const uint32_t major_end = get_subaddress_clamped_sum(index.major, m_subaddress_lookahead_major);
 1608|      2|    for (index2.major = m_subaddress_labels.size(); index2.major < major_end; ++index2.major)
  ------------------
  |  Branch (1608:53): [True: 1, False: 1]
  ------------------
 1609|      1|    {
 1610|      1|      const uint32_t end = get_subaddress_clamped_sum((index2.major == index.major ? index.minor : 0), m_subaddress_lookahead_minor);
  ------------------
  |  Branch (1610:56): [True: 1, False: 0]
  ------------------
 1611|      1|      const std::vector<crypto::public_key> pkeys = hwdev.get_subaddress_spend_public_keys(m_account.get_keys(), index2.major, 0, end);
 1612|      2|      for (index2.minor = 0; index2.minor < end; ++index2.minor)
  ------------------
  |  Branch (1612:30): [True: 1, False: 1]
  ------------------
 1613|      1|      {
 1614|      1|         const crypto::public_key &D = pkeys[index2.minor];
 1615|      1|         m_subaddresses[D] = index2;
 1616|      1|      }
 1617|      1|    }
 1618|      1|    m_subaddress_labels.resize(index.major + 1, {"Untitled account"});
 1619|      1|    m_subaddress_labels[index.major].resize(index.minor + 1);
 1620|      1|    get_account_tags();
 1621|      1|  }
 1622|      0|  else if (m_subaddress_labels[index.major].size() <= index.minor)
  ------------------
  |  Branch (1622:12): [True: 0, False: 0]
  ------------------
 1623|      0|  {
 1624|       |    // add new subaddresses
 1625|      0|    const uint32_t end = get_subaddress_clamped_sum(index.minor, m_subaddress_lookahead_minor);
 1626|      0|    const uint32_t begin = m_subaddress_labels[index.major].size();
 1627|      0|    cryptonote::subaddress_index index2 = {index.major, begin};
 1628|      0|    const std::vector<crypto::public_key> pkeys = hwdev.get_subaddress_spend_public_keys(m_account.get_keys(), index2.major, index2.minor, end);
 1629|      0|    for (; index2.minor < end; ++index2.minor)
  ------------------
  |  Branch (1629:12): [True: 0, False: 0]
  ------------------
 1630|      0|    {
 1631|      0|       const crypto::public_key &D = pkeys[index2.minor - begin];
 1632|      0|       m_subaddresses[D] = index2;
 1633|      0|    }
 1634|      0|    m_subaddress_labels[index.major].resize(index.minor + 1);
 1635|      0|  }
 1636|      1|}
_ZN5tools7wallet225create_one_off_subaddressERKN10cryptonote16subaddress_indexE:
 1639|    711|{
 1640|    711|  const crypto::public_key pkey = get_subaddress_spend_public_key(index);
 1641|    711|  m_subaddresses[pkey] = index;
 1642|    711|}
_ZN5tools7wallet224set_subaddress_lookaheadEmm:
 1947|      1|{
 1948|      1|  THROW_WALLET_EXCEPTION_IF(major == 0, error::wallet_internal_error, "Subaddress major lookahead may not be zero");
  ------------------
  |  | 1040|      1|  if (cond)                                                                                                 \
  |  |  ------------------
  |  |  |  Branch (1040:7): [True: 0, False: 1]
  |  |  ------------------
  |  | 1041|      1|  {                                                                                                         \
  |  | 1042|      0|    LOG_ERROR(#cond << ". THROW EXCEPTION: " << #err_type);                                                 \
  |  |  ------------------
  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1043|      0|    tools::error::throw_wallet_ex<err_type>(std::string(__FILE__ ":" STRINGIZE(__LINE__)), ## __VA_ARGS__); \
  |  |  ------------------
  |  |  |  | 1031|      0|#define STRINGIZE(x) STRINGIZE_DETAIL(x)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1030|      0|#define STRINGIZE_DETAIL(x) #x
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1044|      0|  }
  ------------------
 1949|      1|  THROW_WALLET_EXCEPTION_IF(major > 0xffffffff, error::wallet_internal_error, "Subaddress major lookahead is too large");
  ------------------
  |  | 1040|      1|  if (cond)                                                                                                 \
  |  |  ------------------
  |  |  |  Branch (1040:7): [True: 0, False: 1]
  |  |  ------------------
  |  | 1041|      1|  {                                                                                                         \
  |  | 1042|      0|    LOG_ERROR(#cond << ". THROW EXCEPTION: " << #err_type);                                                 \
  |  |  ------------------
  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1043|      0|    tools::error::throw_wallet_ex<err_type>(std::string(__FILE__ ":" STRINGIZE(__LINE__)), ## __VA_ARGS__); \
  |  |  ------------------
  |  |  |  | 1031|      0|#define STRINGIZE(x) STRINGIZE_DETAIL(x)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1030|      0|#define STRINGIZE_DETAIL(x) #x
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1044|      0|  }
  ------------------
 1950|      1|  THROW_WALLET_EXCEPTION_IF(minor == 0, error::wallet_internal_error, "Subaddress minor lookahead may not be zero");
  ------------------
  |  | 1040|      1|  if (cond)                                                                                                 \
  |  |  ------------------
  |  |  |  Branch (1040:7): [True: 0, False: 1]
  |  |  ------------------
  |  | 1041|      1|  {                                                                                                         \
  |  | 1042|      0|    LOG_ERROR(#cond << ". THROW EXCEPTION: " << #err_type);                                                 \
  |  |  ------------------
  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1043|      0|    tools::error::throw_wallet_ex<err_type>(std::string(__FILE__ ":" STRINGIZE(__LINE__)), ## __VA_ARGS__); \
  |  |  ------------------
  |  |  |  | 1031|      0|#define STRINGIZE(x) STRINGIZE_DETAIL(x)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1030|      0|#define STRINGIZE_DETAIL(x) #x
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1044|      0|  }
  ------------------
 1951|      1|  THROW_WALLET_EXCEPTION_IF(minor > 0xffffffff, error::wallet_internal_error, "Subaddress minor lookahead is too large");
  ------------------
  |  | 1040|      1|  if (cond)                                                                                                 \
  |  |  ------------------
  |  |  |  Branch (1040:7): [True: 0, False: 1]
  |  |  ------------------
  |  | 1041|      1|  {                                                                                                         \
  |  | 1042|      0|    LOG_ERROR(#cond << ". THROW EXCEPTION: " << #err_type);                                                 \
  |  |  ------------------
  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1043|      0|    tools::error::throw_wallet_ex<err_type>(std::string(__FILE__ ":" STRINGIZE(__LINE__)), ## __VA_ARGS__); \
  |  |  ------------------
  |  |  |  | 1031|      0|#define STRINGIZE(x) STRINGIZE_DETAIL(x)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1030|      0|#define STRINGIZE_DETAIL(x) #x
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1044|      0|  }
  ------------------
 1952|      1|  m_subaddress_lookahead_major = major;
 1953|      1|  m_subaddress_lookahead_minor = minor;
 1954|      1|}
_ZNK5tools7wallet221check_acc_out_precompERKN10cryptonote6tx_outERKN6crypto14key_derivationERKNSt3__16vectorIS6_NS9_9allocatorIS6_EEEEmRNS0_14tx_scan_info_tE:
 2089|  23.7k|{
 2090|  23.7k|  hw::device &hwdev = m_account.get_device();
 2091|  23.7k|  boost::unique_lock<hw::device> hwdev_lock (hwdev);
 2092|  23.7k|  hwdev.set_mode(hw::device::TRANSACTION_PARSE);
 2093|  23.7k|  crypto::public_key output_public_key;
 2094|  23.7k|  if (!get_output_public_key(o, output_public_key))
  ------------------
  |  Branch (2094:7): [True: 15.1k, False: 8.59k]
  ------------------
 2095|  15.1k|  {
 2096|  15.1k|     tx_scan_info.error = true;
 2097|  15.1k|     LOG_ERROR("wrong type id in transaction out");
  ------------------
  |  |  100|  15.1k|#define LOG_ERROR(x) MERROR(x)
  |  |  ------------------
  |  |  |  |   75|  15.1k|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   53|  15.1k|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|  15.1k|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|  15.1k|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|  15.1k|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 15.1k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|  15.1k|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2098|  15.1k|     return;
 2099|  15.1k|  }
 2100|  8.59k|  tx_scan_info.received = is_out_to_acc_precomp(m_subaddresses, output_public_key, derivation, additional_derivations, i, hwdev, get_output_view_tag(o));
 2101|  8.59k|  if(tx_scan_info.received)
  ------------------
  |  Branch (2101:6): [True: 0, False: 8.59k]
  ------------------
 2102|      0|  {
 2103|      0|    tx_scan_info.money_transfered = o.amount; // may be 0 for ringct outputs
 2104|      0|  }
 2105|  8.59k|  else
 2106|  8.59k|  {
 2107|  8.59k|    tx_scan_info.money_transfered = 0;
 2108|  8.59k|  }
 2109|  8.59k|  tx_scan_info.error = false;
 2110|  8.59k|}
_ZN5tools7wallet26deinitEv:
 4401|      1|{
 4402|      1|  if(m_is_initialized) {
  ------------------
  |  Branch (4402:6): [True: 1, False: 0]
  ------------------
 4403|      1|    m_is_initialized = false;
 4404|      1|    unlock_keys_file();
 4405|      1|    unlock_background_keys_file();
 4406|      1|    m_account.deinit();
 4407|      1|  }
 4408|      1|  return true;
 4409|      1|}
_ZN5tools7wallet25clearEv:
 4412|      1|{
 4413|      1|  m_blockchain.clear();
 4414|      1|  m_transfers.clear();
 4415|      1|  m_key_images.clear();
 4416|      1|  m_pub_keys.clear();
 4417|      1|  m_unconfirmed_txs.clear();
 4418|      1|  m_payments.clear();
 4419|      1|  m_tx_keys.clear();
 4420|      1|  m_additional_tx_keys.clear();
 4421|      1|  m_confirmed_txs.clear();
 4422|      1|  m_unconfirmed_payments.clear();
 4423|      1|  m_scanned_pool_txs[0].clear();
 4424|      1|  m_scanned_pool_txs[1].clear();
 4425|      1|  m_address_book.clear();
 4426|      1|  m_subaddresses.clear();
 4427|      1|  m_subaddress_labels.clear();
 4428|      1|  m_multisig_rounds_passed = 0;
 4429|      1|  m_device_last_key_image_sync = 0;
 4430|      1|  m_pool_info_query_time = 0;
 4431|      1|  m_skip_to_height = 0;
 4432|      1|  m_background_sync_data = background_sync_data_t{};
 4433|      1|  return true;
 4434|      1|}
_ZN5tools7wallet210setup_keysERKN4epee15wipeable_stringE:
 4765|      1|{
 4766|      1|  crypto::chacha_key key;
 4767|      1|  crypto::generate_chacha_key(password.data(), password.size(), key, m_kdf_rounds);
 4768|       |
 4769|       |  // re-encrypt, but keep viewkey unencrypted
 4770|      1|  if (m_ask_password == AskPasswordToDecrypt && !m_unattended && !m_watch_only)
  ------------------
  |  Branch (4770:7): [True: 1, False: 0]
  |  Branch (4770:49): [True: 1, False: 0]
  |  Branch (4770:66): [True: 1, False: 0]
  ------------------
 4771|      1|  {
 4772|      1|    m_account.encrypt_keys(key);
 4773|      1|    m_account.decrypt_viewkey(key);
 4774|      1|  }
 4775|       |
 4776|      1|  m_cache_key = derive_cache_key(key, config::HASH_KEY_WALLET_CACHE);
 4777|       |
 4778|      1|  get_ringdb_key();
 4779|      1|}
_ZN5tools7wallet220setup_new_blockchainEv:
 5440|      1|{
 5441|      1|  cryptonote::block b;
 5442|      1|  generate_genesis(b);
 5443|      1|  m_blockchain.push_back(get_block_hash(b));
 5444|      1|  m_last_block_reward = cryptonote::get_outs_money_amount(b.miner_tx);
 5445|      1|  add_subaddress_account(tr("Primary account"));
 5446|      1|}
_ZN5tools7wallet216create_keys_fileERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbRKN4epee15wipeable_stringEb:
 5449|      1|{
 5450|      1|  if (!wallet_.empty())
  ------------------
  |  Branch (5450:7): [True: 0, False: 1]
  ------------------
 5451|      0|  {
 5452|      0|    bool r = store_keys(m_keys_file, password, watch_only);
 5453|      0|    THROW_WALLET_EXCEPTION_IF(!r, error::file_save_error, m_keys_file);
  ------------------
  |  | 1040|      0|  if (cond)                                                                                                 \
  |  |  ------------------
  |  |  |  Branch (1040:7): [True: 0, False: 0]
  |  |  ------------------
  |  | 1041|      0|  {                                                                                                         \
  |  | 1042|      0|    LOG_ERROR(#cond << ". THROW EXCEPTION: " << #err_type);                                                 \
  |  |  ------------------
  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1043|      0|    tools::error::throw_wallet_ex<err_type>(std::string(__FILE__ ":" STRINGIZE(__LINE__)), ## __VA_ARGS__); \
  |  |  ------------------
  |  |  |  | 1031|      0|#define STRINGIZE(x) STRINGIZE_DETAIL(x)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1030|      0|#define STRINGIZE_DETAIL(x) #x
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1044|      0|  }
  ------------------
 5454|       |
 5455|      0|    if (create_address_file)
  ------------------
  |  Branch (5455:9): [True: 0, False: 0]
  ------------------
 5456|      0|    {
 5457|      0|      r = save_to_file(m_wallet_file + ".address.txt", m_account.get_public_address_str(m_nettype), true);
 5458|      0|      if(!r) MERROR("String with address text not saved");
  ------------------
  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  ------------------
  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (5458:10): [True: 0, False: 0]
  ------------------
 5459|      0|    }
 5460|      0|  }
 5461|      1|}
_ZN5tools7wallet29init_typeEN2hw6device11device_typeE:
 5519|      1|{
 5520|      1|  m_account_public_address = m_account.get_keys().m_account_address;
 5521|      1|  m_watch_only = false;
 5522|      1|  m_multisig = false;
 5523|      1|  m_multisig_threshold = 0;
 5524|      1|  m_multisig_signers.clear();
 5525|      1|  m_original_keys_available = false;
 5526|      1|  m_key_device_type = device_type;
 5527|      1|}
_ZN5tools7wallet28generateERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKN4epee15wipeable_stringERKNSA_7mlockedINS_8scrubbedIN6crypto9ec_scalarEEEEEbbb:
 5625|      1|{
 5626|      1|  clear();
 5627|      1|  prepare_file_names(wallet_);
 5628|       |
 5629|      1|  if (!wallet_.empty())
  ------------------
  |  Branch (5629:7): [True: 0, False: 1]
  ------------------
 5630|      0|  {
 5631|      0|    boost::system::error_code ignored_ec;
 5632|      0|    THROW_WALLET_EXCEPTION_IF(boost::filesystem::exists(m_wallet_file, ignored_ec), error::file_exists, m_wallet_file);
  ------------------
  |  | 1040|      0|  if (cond)                                                                                                 \
  |  |  ------------------
  |  |  |  Branch (1040:7): [True: 0, False: 0]
  |  |  ------------------
  |  | 1041|      0|  {                                                                                                         \
  |  | 1042|      0|    LOG_ERROR(#cond << ". THROW EXCEPTION: " << #err_type);                                                 \
  |  |  ------------------
  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1043|      0|    tools::error::throw_wallet_ex<err_type>(std::string(__FILE__ ":" STRINGIZE(__LINE__)), ## __VA_ARGS__); \
  |  |  ------------------
  |  |  |  | 1031|      0|#define STRINGIZE(x) STRINGIZE_DETAIL(x)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1030|      0|#define STRINGIZE_DETAIL(x) #x
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1044|      0|  }
  ------------------
 5633|      0|    THROW_WALLET_EXCEPTION_IF(boost::filesystem::exists(m_keys_file,   ignored_ec), error::file_exists, m_keys_file);
  ------------------
  |  | 1040|      0|  if (cond)                                                                                                 \
  |  |  ------------------
  |  |  |  Branch (1040:7): [True: 0, False: 0]
  |  |  ------------------
  |  | 1041|      0|  {                                                                                                         \
  |  | 1042|      0|    LOG_ERROR(#cond << ". THROW EXCEPTION: " << #err_type);                                                 \
  |  |  ------------------
  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1043|      0|    tools::error::throw_wallet_ex<err_type>(std::string(__FILE__ ":" STRINGIZE(__LINE__)), ## __VA_ARGS__); \
  |  |  ------------------
  |  |  |  | 1031|      0|#define STRINGIZE(x) STRINGIZE_DETAIL(x)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1030|      0|#define STRINGIZE_DETAIL(x) #x
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1044|      0|  }
  ------------------
 5634|      0|  }
 5635|       |
 5636|      1|  crypto::secret_key retval = m_account.generate(recovery_param, recover, two_random);
 5637|       |
 5638|      1|  init_type(hw::device::device_type::SOFTWARE);
 5639|      1|  setup_keys(password);
 5640|       |
 5641|       |  // calculate a starting refresh height
 5642|      1|  if(m_refresh_from_block_height == 0 && !recover){
  ------------------
  |  Branch (5642:6): [True: 1, False: 0]
  |  Branch (5642:42): [True: 0, False: 1]
  ------------------
 5643|      0|    m_refresh_from_block_height = estimate_blockchain_height();
 5644|      0|  }
 5645|       |
 5646|      1|  create_keys_file(wallet_, false, password, m_nettype != MAINNET || create_address_file);
  ------------------
  |  Branch (5646:46): [True: 0, False: 1]
  |  Branch (5646:70): [True: 0, False: 1]
  ------------------
 5647|       |
 5648|      1|  setup_new_blockchain();
 5649|       |
 5650|      1|  if (!wallet_.empty())
  ------------------
  |  Branch (5650:7): [True: 0, False: 1]
  ------------------
 5651|      0|    store();
 5652|       |
 5653|      1|  return retval;
 5654|      1|}
_ZN5tools7wallet218prepare_file_namesERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 6278|      1|{
 6279|      1|  do_prepare_file_names(file_path, m_keys_file, m_wallet_file, m_mms_file);
 6280|      1|  return true;
 6281|      1|}
_ZNK5tools7wallet236generate_chacha_key_from_secret_keysERN4epee7mlockedINS_8scrubbedINSt3__15arrayIhLm32EEEEEEE:
 6421|      1|{
 6422|      1|  hw::device &hwdev =  m_account.get_device();
 6423|      1|  return hwdev.generate_chacha_key(m_account.get_keys(), key, m_kdf_rounds);
 6424|      1|}
_ZN5tools7wallet27sign_txERNS0_15unsigned_tx_setERNSt3__16vectorINS0_10pending_txENS3_9allocatorIS5_EEEERNS0_13signed_tx_setE:
 7777|  9.74k|{
 7778|  9.74k|  if (!std::get<2>(exported_txs.new_transfers).empty())
  ------------------
  |  Branch (7778:7): [True: 1.18k, False: 8.56k]
  ------------------
 7779|  1.18k|    import_outputs(exported_txs.new_transfers);
 7780|  8.56k|  else if (!std::get<2>(exported_txs.transfers).empty())
  ------------------
  |  Branch (7780:12): [True: 908, False: 7.65k]
  ------------------
 7781|    908|    import_outputs(exported_txs.transfers);
 7782|       |
 7783|       |  // sign the transactions
 7784|  11.8k|  for (size_t n = 0; n < exported_txs.txes.size(); ++n)
  ------------------
  |  Branch (7784:22): [True: 2.05k, False: 9.74k]
  ------------------
 7785|  2.05k|  {
 7786|  2.05k|    tools::wallet2::tx_construction_data &sd = exported_txs.txes[n];
 7787|  2.05k|    THROW_WALLET_EXCEPTION_IF(sd.sources.empty(), error::wallet_internal_error, "Empty sources");
  ------------------
  |  | 1040|  2.05k|  if (cond)                                                                                                 \
  |  |  ------------------
  |  |  |  Branch (1040:7): [True: 567, False: 1.49k]
  |  |  ------------------
  |  | 1041|  2.05k|  {                                                                                                         \
  |  | 1042|    567|    LOG_ERROR(#cond << ". THROW EXCEPTION: " << #err_type);                                                 \
  |  |  ------------------
  |  |  |  |  100|    567|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|    567|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|    567|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|    567|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|    567|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|    567|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 567]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|    567|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1043|    567|    tools::error::throw_wallet_ex<err_type>(std::string(__FILE__ ":" STRINGIZE(__LINE__)), ## __VA_ARGS__); \
  |  |  ------------------
  |  |  |  | 1031|    567|#define STRINGIZE(x) STRINGIZE_DETAIL(x)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1030|    567|#define STRINGIZE_DETAIL(x) #x
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1044|    567|  }
  ------------------
 7788|  2.05k|    THROW_WALLET_EXCEPTION_IF(sd.unlock_time, error::nonzero_unlock_time);
  ------------------
  |  | 1040|  2.05k|  if (cond)                                                                                                 \
  |  |  ------------------
  |  |  |  Branch (1040:7): [True: 133, False: 1.92k]
  |  |  ------------------
  |  | 1041|  2.05k|  {                                                                                                         \
  |  | 1042|    133|    LOG_ERROR(#cond << ". THROW EXCEPTION: " << #err_type);                                                 \
  |  |  ------------------
  |  |  |  |  100|    133|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|    133|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|    133|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|    133|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|    133|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|    133|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 133]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|    133|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1043|    133|    tools::error::throw_wallet_ex<err_type>(std::string(__FILE__ ":" STRINGIZE(__LINE__)), ## __VA_ARGS__); \
  |  |  ------------------
  |  |  |  | 1031|    133|#define STRINGIZE(x) STRINGIZE_DETAIL(x)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1030|    133|#define STRINGIZE_DETAIL(x) #x
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1044|    133|  }
  ------------------
 7789|  2.05k|    LOG_PRINT_L1(" " << (n+1) << ": " << sd.sources.size() << " inputs, ring size " << sd.sources[0].outputs.size());
  ------------------
  |  |  102|  2.05k|#define LOG_PRINT_L1(x) MINFO(x)
  |  |  ------------------
  |  |  |  |   77|  2.05k|#define MINFO(x) MCINFO(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|  2.05k|#define MCINFO(cat,x) MCLOG(el::Level::Info,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|  2.05k|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|  2.05k|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|  2.05k|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 2.05k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|  2.05k|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 7790|  2.05k|    signed_txes.ptx.push_back(pending_tx());
 7791|  2.05k|    tools::wallet2::pending_tx &ptx = signed_txes.ptx.back();
 7792|  2.05k|    rct::RCTConfig rct_config = sd.rct_config;
 7793|  2.05k|    crypto::secret_key tx_key;
 7794|  2.05k|    std::vector<crypto::secret_key> additional_tx_keys;
 7795|  2.05k|    bool r = cryptonote::construct_tx_and_get_tx_key(m_account.get_keys(), m_subaddresses, sd.sources, sd.splitted_dsts, sd.change_dts.addr, sd.extra, ptx.tx, tx_key, additional_tx_keys, sd.use_rct, rct_config, sd.use_view_tags);
 7796|  2.05k|    THROW_WALLET_EXCEPTION_IF(!r, error::tx_not_constructed, sd.sources, sd.splitted_dsts, m_nettype);
  ------------------
  |  | 1040|  2.05k|  if (cond)                                                                                                 \
  |  |  ------------------
  |  |  |  Branch (1040:7): [True: 1.35k, False: 700]
  |  |  ------------------
  |  | 1041|  2.05k|  {                                                                                                         \
  |  | 1042|  1.35k|    LOG_ERROR(#cond << ". THROW EXCEPTION: " << #err_type);                                                 \
  |  |  ------------------
  |  |  |  |  100|  1.35k|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|  1.35k|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|  1.35k|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|  1.35k|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|  1.35k|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|  1.35k|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 1.35k]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|  1.35k|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1043|  1.35k|    tools::error::throw_wallet_ex<err_type>(std::string(__FILE__ ":" STRINGIZE(__LINE__)), ## __VA_ARGS__); \
  |  |  ------------------
  |  |  |  | 1031|  1.35k|#define STRINGIZE(x) STRINGIZE_DETAIL(x)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1030|  1.35k|#define STRINGIZE_DETAIL(x) #x
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1044|  1.35k|  }
  ------------------
 7797|       |    // we don't test tx size, because we don't know the current limit, due to not having a blockchain,
 7798|       |    // and it's a bit pointless to fail there anyway, since it'd be a (good) guess only. We sign anyway,
 7799|       |    // and if we really go over limit, the daemon will reject when it gets submitted. Chances are it's
 7800|       |    // OK anyway since it was generated in the first place, and rerolling should be within a few bytes.
 7801|       |
 7802|       |    // normally, the tx keys are saved in commit_tx, when the tx is actually sent to the daemon.
 7803|       |    // we can't do that here since the tx will be sent from the compromised wallet, which we don't want
 7804|       |    // to see that info, so we save it here
 7805|  2.05k|    if (store_tx_info() && tx_key != crypto::null_skey)
  ------------------
  |  Branch (7805:9): [True: 0, False: 2.05k]
  |  Branch (7805:28): [True: 0, False: 0]
  ------------------
 7806|      0|    {
 7807|      0|      const crypto::hash txid = get_transaction_hash(ptx.tx);
 7808|      0|      m_tx_keys[txid] = tx_key;
 7809|      0|      m_additional_tx_keys[txid] = additional_tx_keys;
 7810|      0|    }
 7811|       |
 7812|  2.05k|    std::string key_images;
 7813|  2.05k|    bool all_are_txin_to_key = std::all_of(ptx.tx.vin.begin(), ptx.tx.vin.end(), [&](const txin_v& s_e) -> bool
 7814|  2.05k|    {
 7815|  2.05k|      CHECKED_GET_SPECIFIC_VARIANT(s_e, const txin_to_key, in, false);
 7816|  2.05k|      key_images += boost::to_string(in.k_image) + " ";
 7817|  2.05k|      return true;
 7818|  2.05k|    });
 7819|  2.05k|    THROW_WALLET_EXCEPTION_IF(!all_are_txin_to_key, error::unexpected_txin_type, ptx.tx);
  ------------------
  |  | 1040|  2.05k|  if (cond)                                                                                                 \
  |  |  ------------------
  |  |  |  Branch (1040:7): [True: 0, False: 2.05k]
  |  |  ------------------
  |  | 1041|  2.05k|  {                                                                                                         \
  |  | 1042|      0|    LOG_ERROR(#cond << ". THROW EXCEPTION: " << #err_type);                                                 \
  |  |  ------------------
  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1043|      0|    tools::error::throw_wallet_ex<err_type>(std::string(__FILE__ ":" STRINGIZE(__LINE__)), ## __VA_ARGS__); \
  |  |  ------------------
  |  |  |  | 1031|      0|#define STRINGIZE(x) STRINGIZE_DETAIL(x)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1030|      0|#define STRINGIZE_DETAIL(x) #x
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1044|      0|  }
  ------------------
 7820|       |
 7821|  2.05k|    ptx.key_images = key_images;
 7822|  2.05k|    ptx.fee = 0;
 7823|  2.05k|    for (const auto &i: sd.sources) ptx.fee += i.amount;
  ------------------
  |  Branch (7823:23): [True: 0, False: 2.05k]
  ------------------
 7824|  2.05k|    for (const auto &i: sd.splitted_dsts) ptx.fee -= i.amount;
  ------------------
  |  Branch (7824:23): [True: 0, False: 2.05k]
  ------------------
 7825|  2.05k|    ptx.dust = 0;
 7826|  2.05k|    ptx.dust_added_to_fee = false;
 7827|  2.05k|    ptx.change_dts = sd.change_dts;
 7828|  2.05k|    ptx.selected_transfers = sd.selected_transfers;
 7829|  2.05k|    ptx.tx_key = rct::rct2sk(rct::identity()); // don't send it back to the untrusted view wallet
 7830|  2.05k|    ptx.dests = sd.dests;
 7831|  2.05k|    ptx.construction_data = sd;
 7832|       |
 7833|  2.05k|    txs.push_back(ptx);
 7834|       |
 7835|       |    // add tx keys only to ptx
 7836|  2.05k|    txs.back().tx_key = tx_key;
 7837|  2.05k|    txs.back().additional_tx_keys = additional_tx_keys;
 7838|  2.05k|  }
 7839|       |
 7840|       |  // add key image mapping for these txes
 7841|  9.74k|  const account_keys &keys = get_account().get_keys();
 7842|  9.74k|  hw::device &hwdev = m_account.get_device();
 7843|  9.74k|  for (size_t n = 0; n < exported_txs.txes.size(); ++n)
  ------------------
  |  Branch (7843:22): [True: 0, False: 9.74k]
  ------------------
 7844|      0|  {
 7845|      0|    const cryptonote::transaction &tx = signed_txes.ptx[n].tx;
 7846|       |
 7847|      0|    crypto::key_derivation derivation;
 7848|      0|    std::vector<crypto::key_derivation> additional_derivations;
 7849|       |
 7850|      0|    crypto::public_key tx_pub_key = get_tx_pub_key_from_extra(tx);
 7851|      0|    std::vector<crypto::public_key> additional_tx_pub_keys;
 7852|      0|    for (const crypto::secret_key &skey: txs[n].additional_tx_keys)
  ------------------
  |  Branch (7852:40): [True: 0, False: 0]
  ------------------
 7853|      0|    {
 7854|      0|      additional_tx_pub_keys.resize(additional_tx_pub_keys.size() + 1);
 7855|      0|      crypto::secret_key_to_public_key(skey, additional_tx_pub_keys.back());
 7856|      0|    }
 7857|       |
 7858|       |    // compute derivations
 7859|      0|    hwdev.set_mode(hw::device::TRANSACTION_PARSE);
 7860|      0|    if (!hwdev.generate_key_derivation(tx_pub_key, keys.m_view_secret_key, derivation))
  ------------------
  |  Branch (7860:9): [True: 0, False: 0]
  ------------------
 7861|      0|    {
 7862|      0|      MWARNING("Failed to generate key derivation from tx pubkey in " << cryptonote::get_transaction_hash(tx) << ", skipping");
  ------------------
  |  |   76|      0|#define MWARNING(x) MCWARNING(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  ------------------
  |  |  |  |   54|      0|#define MCWARNING(cat,x) MCLOG(el::Level::Warning,cat, el::Color::Default, x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 7863|      0|      static_assert(sizeof(derivation) == sizeof(rct::key), "Mismatched sizes of key_derivation and rct::key");
 7864|      0|      memcpy(&derivation, rct::identity().bytes, sizeof(derivation));
 7865|      0|    }
 7866|      0|    for (size_t i = 0; i < additional_tx_pub_keys.size(); ++i)
  ------------------
  |  Branch (7866:24): [True: 0, False: 0]
  ------------------
 7867|      0|    {
 7868|      0|      additional_derivations.push_back({});
 7869|      0|      if (!hwdev.generate_key_derivation(additional_tx_pub_keys[i], keys.m_view_secret_key, additional_derivations.back()))
  ------------------
  |  Branch (7869:11): [True: 0, False: 0]
  ------------------
 7870|      0|      {
 7871|      0|        MWARNING("Failed to generate key derivation from additional tx pubkey in " << cryptonote::get_transaction_hash(tx) << ", skipping");
  ------------------
  |  |   76|      0|#define MWARNING(x) MCWARNING(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  ------------------
  |  |  |  |   54|      0|#define MCWARNING(cat,x) MCLOG(el::Level::Warning,cat, el::Color::Default, x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 7872|      0|        memcpy(&additional_derivations.back(), rct::identity().bytes, sizeof(crypto::key_derivation));
 7873|      0|      }
 7874|      0|    }
 7875|       |
 7876|      0|    for (size_t i = 0; i < tx.vout.size(); ++i)
  ------------------
  |  Branch (7876:24): [True: 0, False: 0]
  ------------------
 7877|      0|    {
 7878|      0|      crypto::public_key output_public_key;
 7879|      0|      if (!get_output_public_key(tx.vout[i], output_public_key))
  ------------------
  |  Branch (7879:11): [True: 0, False: 0]
  ------------------
 7880|      0|        continue;
 7881|       |
 7882|       |      // if this output is back to this wallet, we can calculate its key image already
 7883|      0|      if (!is_out_to_acc_precomp(m_subaddresses, output_public_key, derivation, additional_derivations, i, hwdev, get_output_view_tag(tx.vout[i])))
  ------------------
  |  Branch (7883:11): [True: 0, False: 0]
  ------------------
 7884|      0|        continue;
 7885|      0|      crypto::key_image ki;
 7886|      0|      cryptonote::keypair in_ephemeral;
 7887|      0|      if (generate_key_image_helper(keys, m_subaddresses, output_public_key, tx_pub_key, additional_tx_pub_keys, i, in_ephemeral, ki, hwdev))
  ------------------
  |  Branch (7887:11): [True: 0, False: 0]
  ------------------
 7888|      0|        signed_txes.tx_key_images[output_public_key] = ki;
 7889|      0|      else
 7890|      0|        MERROR("Failed to calculate key image");
  ------------------
  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  ------------------
  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 7891|      0|    }
 7892|      0|  }
 7893|       |
 7894|       |  // add key images
 7895|  9.74k|  signed_txes.key_images.resize(m_transfers.size());
 7896|  45.0k|  for (size_t i = 0; i < m_transfers.size(); ++i)
  ------------------
  |  Branch (7896:22): [True: 35.3k, False: 9.74k]
  ------------------
 7897|  35.3k|  {
 7898|  35.3k|    if (!m_transfers[i].m_key_image_known || m_transfers[i].m_key_image_partial)
  ------------------
  |  Branch (7898:9): [True: 34.6k, False: 714]
  |  Branch (7898:46): [True: 0, False: 714]
  ------------------
 7899|  35.3k|      LOG_PRINT_L0("WARNING: key image not known in signing wallet at index " << i);
  ------------------
  |  |  101|  35.3k|#define LOG_PRINT_L0(x) MWARNING(x)
  |  |  ------------------
  |  |  |  |   76|  35.3k|#define MWARNING(x) MCWARNING(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   54|  35.3k|#define MCWARNING(cat,x) MCLOG(el::Level::Warning,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|  34.6k|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|  34.6k|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|  34.6k|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 34.6k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|  34.6k|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 7900|  35.3k|    signed_txes.key_images[i] = m_transfers[i].m_key_image;
 7901|  35.3k|  }
 7902|       |
 7903|  9.74k|  return true;
 7904|  9.74k|}
_ZN5tools7wallet27sign_txERNS0_15unsigned_tx_setERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERNS3_6vectorINS0_10pending_txENS7_ISD_EEEEb:
 7907|  9.74k|{
 7908|       |  // sign the transactions
 7909|  9.74k|  signed_tx_set signed_txes;
 7910|  9.74k|  std::string ciphertext = sign_tx_dump_to_str(exported_txs, txs, signed_txes);
 7911|  9.74k|  if (ciphertext.empty())
  ------------------
  |  Branch (7911:7): [True: 0, False: 9.74k]
  ------------------
 7912|      0|  {
 7913|      0|    LOG_PRINT_L0("Failed to sign unsigned_tx_set");
  ------------------
  |  |  101|      0|#define LOG_PRINT_L0(x) MWARNING(x)
  |  |  ------------------
  |  |  |  |   76|      0|#define MWARNING(x) MCWARNING(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   54|      0|#define MCWARNING(cat,x) MCLOG(el::Level::Warning,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 7914|      0|    return false;
 7915|      0|  }
 7916|       |
 7917|  9.74k|  if (!save_to_file(signed_filename, ciphertext))
  ------------------
  |  Branch (7917:7): [True: 0, False: 9.74k]
  ------------------
 7918|      0|  {
 7919|      0|    LOG_PRINT_L0("Failed to save file to " << signed_filename);
  ------------------
  |  |  101|      0|#define LOG_PRINT_L0(x) MWARNING(x)
  |  |  ------------------
  |  |  |  |   76|      0|#define MWARNING(x) MCWARNING(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   54|      0|#define MCWARNING(cat,x) MCLOG(el::Level::Warning,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 7920|      0|    return false;
 7921|      0|  }
 7922|       |  // export signed raw tx without encryption
 7923|  9.74k|  if (export_raw)
  ------------------
  |  Branch (7923:7): [True: 0, False: 9.74k]
  ------------------
 7924|      0|  {
 7925|      0|    for (size_t i = 0; i < signed_txes.ptx.size(); ++i)
  ------------------
  |  Branch (7925:24): [True: 0, False: 0]
  ------------------
 7926|      0|    {
 7927|      0|      std::string tx_as_hex = epee::string_tools::buff_to_hex_nodelimer(tx_to_blob(signed_txes.ptx[i].tx));
 7928|      0|      std::string raw_filename = signed_filename + "_raw" + (signed_txes.ptx.size() == 1 ? "" : ("_" + std::to_string(i)));
  ------------------
  |  Branch (7928:62): [True: 0, False: 0]
  ------------------
 7929|      0|      if (!save_to_file(raw_filename, tx_as_hex))
  ------------------
  |  Branch (7929:11): [True: 0, False: 0]
  ------------------
 7930|      0|      {
 7931|      0|        LOG_PRINT_L0("Failed to save file to " << raw_filename);
  ------------------
  |  |  101|      0|#define LOG_PRINT_L0(x) MWARNING(x)
  |  |  ------------------
  |  |  |  |   76|      0|#define MWARNING(x) MCWARNING(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   54|      0|#define MCWARNING(cat,x) MCLOG(el::Level::Warning,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 7932|      0|        return false;
 7933|      0|      }
 7934|      0|    }
 7935|      0|  }
 7936|  9.74k|  return true;
 7937|  9.74k|}
_ZN5tools7wallet219sign_tx_dump_to_strERNS0_15unsigned_tx_setERNSt3__16vectorINS0_10pending_txENS3_9allocatorIS5_EEEERNS0_13signed_tx_setE:
 7940|  9.74k|{
 7941|       |  // sign the transactions
 7942|  9.74k|  bool r = sign_tx(exported_txs, ptx, signed_txes);
 7943|  9.74k|  if (!r)
  ------------------
  |  Branch (7943:7): [True: 0, False: 9.74k]
  ------------------
 7944|      0|  {
 7945|      0|    LOG_PRINT_L0("Failed to sign unsigned_tx_set");
  ------------------
  |  |  101|      0|#define LOG_PRINT_L0(x) MWARNING(x)
  |  |  ------------------
  |  |  |  |   76|      0|#define MWARNING(x) MCWARNING(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   54|      0|#define MCWARNING(cat,x) MCLOG(el::Level::Warning,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 7946|      0|    return std::string();
 7947|      0|  }
 7948|       |
 7949|       |  // save as binary
 7950|  9.74k|  std::ostringstream oss;
 7951|  9.74k|  binary_archive<true> ar(oss);
 7952|  9.74k|  try
 7953|  9.74k|  {
 7954|  9.74k|    if (!::serialization::serialize(ar, signed_txes))
  ------------------
  |  Branch (7954:9): [True: 0, False: 9.74k]
  ------------------
 7955|      0|      return std::string();
 7956|  9.74k|  }
 7957|  9.74k|  catch(...)
 7958|  9.74k|  {
 7959|      0|    return std::string();
 7960|      0|  }
 7961|  5.59k|  LOG_PRINT_L3("Saving signed tx data (with encryption): " << oss.str());
  ------------------
  |  |  104|  5.59k|#define LOG_PRINT_L3(x) MTRACE(x)
  |  |  ------------------
  |  |  |  |   79|  5.59k|#define MTRACE(x) MCTRACE(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  5.59k|#define MCTRACE(cat,x) MCLOG(el::Level::Trace,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|  5.59k|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|  5.59k|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|  5.59k|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 5.59k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|  5.59k|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 7962|  5.59k|  std::string ciphertext = encrypt_with_view_secret_key(oss.str());
 7963|  5.59k|  return std::string(SIGNED_TX_PREFIX) + ciphertext;
  ------------------
  |  |  114|  5.59k|#define SIGNED_TX_PREFIX "Monero signed tx set\005"
  ------------------
 7964|  9.74k|}
_ZN5tools7wallet214get_ringdb_keyEv:
 8736|      1|{
 8737|      1|  if (!m_ringdb_key)
  ------------------
  |  Branch (8737:7): [True: 1, False: 0]
  ------------------
 8738|      1|  {
 8739|      1|    MINFO("caching ringdb key");
  ------------------
  |  |   77|      1|#define MINFO(x) MCINFO(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  ------------------
  |  |  |  |   55|      1|#define MCINFO(cat,x) MCLOG(el::Level::Info,cat, el::Color::Default, x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      1|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   43|      1|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |   44|      1|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 1]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |   47|      1|  } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8740|      1|    crypto::chacha_key key;
 8741|      1|    generate_chacha_key_from_secret_keys(key);
 8742|      1|    m_ringdb_key = key;
 8743|      1|  }
 8744|      1|  return *m_ringdb_key;
 8745|      1|}
_ZN5tools7wallet216unlock_keys_fileEv:
 8997|      1|{
 8998|      1|  if (m_wallet_file.empty())
  ------------------
  |  Branch (8998:7): [True: 1, False: 0]
  ------------------
 8999|      1|    return true;
 9000|      0|  if (!m_keys_file_locker)
  ------------------
  |  Branch (9000:7): [True: 0, False: 0]
  ------------------
 9001|      0|  {
 9002|      0|    MDEBUG(m_keys_file << " is already unlocked.");
  ------------------
  |  |   78|      0|#define MDEBUG(x) MCDEBUG(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  ------------------
  |  |  |  |   56|      0|#define MCDEBUG(cat,x) MCLOG(el::Level::Debug,cat, el::Color::Default, x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 9003|      0|    return false;
 9004|      0|  }
 9005|      0|  m_keys_file_locker.reset();
 9006|      0|  return true;
 9007|      0|}
_ZN5tools7wallet227unlock_background_keys_fileEv:
 9027|      1|{
 9028|      1|  if (!m_background_keys_file_locker)
  ------------------
  |  Branch (9028:7): [True: 1, False: 0]
  ------------------
 9029|      1|  {
 9030|      1|    MDEBUG("background keys file locker is not set");
  ------------------
  |  |   78|      1|#define MDEBUG(x) MCDEBUG(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  ------------------
  |  |  |  |   56|      1|#define MCDEBUG(cat,x) MCLOG(el::Level::Debug,cat, el::Color::Default, x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      1|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   43|      1|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |   44|      1|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 1]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |   47|      1|  } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 9031|      1|    return false;
 9032|      1|  }
 9033|      0|  m_background_keys_file_locker.reset();
 9034|      0|  return true;
 9035|      1|}
_ZNK5tools7wallet218get_daemon_addressEv:
12904|      1|{
12905|      1|  return m_daemon_address;
12906|      1|}
_ZN5tools7wallet216get_account_tagsEv:
13023|      1|{
13024|       |  // ensure consistency
13025|      1|  if (m_account_tags.second.size() != get_num_subaddress_accounts())
  ------------------
  |  Branch (13025:7): [True: 1, False: 0]
  ------------------
13026|      1|    m_account_tags.second.resize(get_num_subaddress_accounts(), "");
13027|      1|  for (const std::string& tag : m_account_tags.second)
  ------------------
  |  Branch (13027:31): [True: 1, False: 1]
  ------------------
13028|      1|  {
13029|      1|    if (!tag.empty() && m_account_tags.first.count(tag) == 0)
  ------------------
  |  Branch (13029:9): [True: 0, False: 1]
  |  Branch (13029:25): [True: 0, False: 0]
  ------------------
13030|      0|      m_account_tags.first.insert({tag, ""});
13031|      1|  }
13032|      1|  for (auto i = m_account_tags.first.begin(); i != m_account_tags.first.end(); )
  ------------------
  |  Branch (13032:47): [True: 0, False: 1]
  ------------------
13033|      0|  {
13034|      0|    if (std::find(m_account_tags.second.begin(), m_account_tags.second.end(), i->first) == m_account_tags.second.end())
  ------------------
  |  Branch (13034:9): [True: 0, False: 0]
  ------------------
13035|      0|      i = m_account_tags.first.erase(i);
13036|      0|    else
13037|      0|      ++i;
13038|      0|  }
13039|      1|  return m_account_tags;
13040|      1|}
_ZNK5tools7wallet233get_tx_pub_key_from_received_outsERKNS0_16transfer_detailsE:
13223|    662|{
13224|    662|  std::vector<tx_extra_field> tx_extra_fields;
13225|    662|  if(!parse_tx_extra(td.m_tx.extra, tx_extra_fields))
  ------------------
  |  Branch (13225:6): [True: 357, False: 305]
  ------------------
13226|    357|  {
13227|       |    // Extra may only be partially parsed, it's OK if tx_extra_fields contains public key
13228|    357|  }
13229|       |
13230|       |  // Due to a previous bug, there might be more than one tx pubkey in extra, one being
13231|       |  // the result of a previously discarded signature.
13232|       |  // For speed, since scanning for outputs is a slow process, we check whether extra
13233|       |  // contains more than one pubkey. If not, the first one is returned. If yes, they're
13234|       |  // checked for whether they yield at least one output
13235|    662|  tx_extra_pub_key pub_key_field;
13236|    662|  THROW_WALLET_EXCEPTION_IF(!find_tx_extra_field_by_type(tx_extra_fields, pub_key_field, 0), error::wallet_internal_error,
  ------------------
  |  | 1040|    662|  if (cond)                                                                                                 \
  |  |  ------------------
  |  |  |  Branch (1040:7): [True: 180, False: 482]
  |  |  ------------------
  |  | 1041|    662|  {                                                                                                         \
  |  | 1042|    180|    LOG_ERROR(#cond << ". THROW EXCEPTION: " << #err_type);                                                 \
  |  |  ------------------
  |  |  |  |  100|    180|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|    180|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|    180|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|    180|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|    180|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|    180|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 180]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|    180|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1043|    180|    tools::error::throw_wallet_ex<err_type>(std::string(__FILE__ ":" STRINGIZE(__LINE__)), ## __VA_ARGS__); \
  |  |  ------------------
  |  |  |  | 1031|    180|#define STRINGIZE(x) STRINGIZE_DETAIL(x)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1030|    180|#define STRINGIZE_DETAIL(x) #x
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1044|    180|  }
  ------------------
13237|    662|      "Public key wasn't found in the transaction extra");
13238|    662|  const crypto::public_key tx_pub_key = pub_key_field.pub_key;
13239|    662|  bool two_found = find_tx_extra_field_by_type(tx_extra_fields, pub_key_field, 1);
13240|    662|  if (!two_found) {
  ------------------
  |  Branch (13240:7): [True: 302, False: 360]
  ------------------
13241|       |    // easy case, just one found
13242|    302|    return tx_pub_key;
13243|    302|  }
13244|       |
13245|       |  // more than one, loop and search
13246|    360|  const cryptonote::account_keys& keys = m_account.get_keys();
13247|    360|  size_t pk_index = 0;
13248|    360|  hw::device &hwdev = m_account.get_device();
13249|       |
13250|  1.43k|  while (find_tx_extra_field_by_type(tx_extra_fields, pub_key_field, pk_index++)) {
  ------------------
  |  Branch (13250:10): [True: 1.07k, False: 360]
  ------------------
13251|  1.07k|    const crypto::public_key tx_pub_key = pub_key_field.pub_key;
13252|  1.07k|    crypto::key_derivation derivation;
13253|  1.07k|    bool r = hwdev.generate_key_derivation(tx_pub_key, keys.m_view_secret_key, derivation);
13254|  1.07k|    THROW_WALLET_EXCEPTION_IF(!r, error::wallet_internal_error, "Failed to generate key derivation");
  ------------------
  |  | 1040|  1.07k|  if (cond)                                                                                                 \
  |  |  ------------------
  |  |  |  Branch (1040:7): [True: 55, False: 1.01k]
  |  |  ------------------
  |  | 1041|  1.07k|  {                                                                                                         \
  |  | 1042|     55|    LOG_ERROR(#cond << ". THROW EXCEPTION: " << #err_type);                                                 \
  |  |  ------------------
  |  |  |  |  100|     55|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|     55|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|     55|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|     55|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|     55|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|     55|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 55]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|     55|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1043|     55|    tools::error::throw_wallet_ex<err_type>(std::string(__FILE__ ":" STRINGIZE(__LINE__)), ## __VA_ARGS__); \
  |  |  ------------------
  |  |  |  | 1031|     55|#define STRINGIZE(x) STRINGIZE_DETAIL(x)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1030|     55|#define STRINGIZE_DETAIL(x) #x
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1044|     55|  }
  ------------------
13255|       |
13256|  24.8k|    for (size_t i = 0; i < td.m_tx.vout.size(); ++i)
  ------------------
  |  Branch (13256:24): [True: 23.7k, False: 1.07k]
  ------------------
13257|  23.7k|    {
13258|  23.7k|      tx_scan_info_t tx_scan_info;
13259|  23.7k|      check_acc_out_precomp(td.m_tx.vout[i], derivation, {}, i, tx_scan_info);
13260|  23.7k|      if (!tx_scan_info.error && tx_scan_info.received)
  ------------------
  |  Branch (13260:11): [True: 8.59k, False: 15.1k]
  |  Branch (13260:34): [True: 0, False: 8.59k]
  ------------------
13261|      0|        return tx_pub_key;
13262|  23.7k|    }
13263|  1.07k|  }
13264|       |
13265|       |  // we found no key yielding an output, but it might be in the additional
13266|       |  // tx pub keys only, which we do not need to check, so return the first one
13267|    360|  return tx_pub_key;
13268|    360|}
_ZN5tools7wallet214import_outputsERKNSt3__15tupleIJmmNS1_6vectorINS0_16transfer_detailsENS1_9allocatorIS4_EEEEEEE:
14259|    908|{
14260|    908|  PERF_TIMER(import_outputs);
  ------------------
  |  |   82|    908|#define PERF_TIMER(name) PERF_TIMER_UNIT(name, 1000000)
  |  |  ------------------
  |  |  |  |   80|    908|#define PERF_TIMER_UNIT(name, unit) tools::LoggingPerformanceTimer PERF_TIMER_NAME(name)(#name, "perf." MONERO_DEFAULT_LOG_CATEGORY, unit, tools::performance_timer_log_level)
  |  |  |  |  ------------------
  |  |  |  |  |  |   79|    908|#define PERF_TIMER_NAME(name) pt_##name
  |  |  |  |  ------------------
  |  |  |  |               #define PERF_TIMER_UNIT(name, unit) tools::LoggingPerformanceTimer PERF_TIMER_NAME(name)(#name, "perf." MONERO_DEFAULT_LOG_CATEGORY, unit, tools::performance_timer_log_level)
  |  |  |  |  ------------------
  |  |  |  |  |  |  105|    908|#define MONERO_DEFAULT_LOG_CATEGORY "wallet.wallet2"
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
14261|       |
14262|    908|  THROW_WALLET_EXCEPTION_IF(m_has_ever_refreshed_from_node, error::wallet_internal_error,
  ------------------
  |  | 1040|    908|  if (cond)                                                                                                 \
  |  |  ------------------
  |  |  |  Branch (1040:7): [True: 0, False: 908]
  |  |  ------------------
  |  | 1041|    908|  {                                                                                                         \
  |  | 1042|      0|    LOG_ERROR(#cond << ". THROW EXCEPTION: " << #err_type);                                                 \
  |  |  ------------------
  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1043|      0|    tools::error::throw_wallet_ex<err_type>(std::string(__FILE__ ":" STRINGIZE(__LINE__)), ## __VA_ARGS__); \
  |  |  ------------------
  |  |  |  | 1031|      0|#define STRINGIZE(x) STRINGIZE_DETAIL(x)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1030|      0|#define STRINGIZE_DETAIL(x) #x
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1044|      0|  }
  ------------------
14263|    908|      "Hot wallets cannot import outputs");
14264|       |
14265|       |  // we can now import piecemeal
14266|    908|  const size_t offset = std::get<0>(outputs);
14267|    908|  const size_t num_outputs = std::get<1>(outputs);
14268|    908|  const std::vector<tools::wallet2::transfer_details> &output_array = std::get<2>(outputs);
14269|       |
14270|    908|  THROW_WALLET_EXCEPTION_IF(offset > m_transfers.size(), error::wallet_internal_error,
  ------------------
  |  | 1040|    908|  if (cond)                                                                                                 \
  |  |  ------------------
  |  |  |  Branch (1040:7): [True: 130, False: 778]
  |  |  ------------------
  |  | 1041|    908|  {                                                                                                         \
  |  | 1042|    130|    LOG_ERROR(#cond << ". THROW EXCEPTION: " << #err_type);                                                 \
  |  |  ------------------
  |  |  |  |  100|    130|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|    130|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|    130|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|    130|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|    130|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|    130|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 130]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|    130|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1043|    130|    tools::error::throw_wallet_ex<err_type>(std::string(__FILE__ ":" STRINGIZE(__LINE__)), ## __VA_ARGS__); \
  |  |  ------------------
  |  |  |  | 1031|    130|#define STRINGIZE(x) STRINGIZE_DETAIL(x)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1030|    130|#define STRINGIZE_DETAIL(x) #x
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1044|    130|  }
  ------------------
14271|    908|      "Imported outputs omit more outputs that we know of");
14272|       |
14273|    908|  THROW_WALLET_EXCEPTION_IF(offset + output_array.size() > num_outputs, error::wallet_internal_error,
  ------------------
  |  | 1040|    908|  if (cond)                                                                                                 \
  |  |  ------------------
  |  |  |  Branch (1040:7): [True: 0, False: 908]
  |  |  ------------------
  |  | 1041|    908|  {                                                                                                         \
  |  | 1042|      0|    LOG_ERROR(#cond << ". THROW EXCEPTION: " << #err_type);                                                 \
  |  |  ------------------
  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1043|      0|    tools::error::throw_wallet_ex<err_type>(std::string(__FILE__ ":" STRINGIZE(__LINE__)), ## __VA_ARGS__); \
  |  |  ------------------
  |  |  |  | 1031|      0|#define STRINGIZE(x) STRINGIZE_DETAIL(x)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1030|      0|#define STRINGIZE_DETAIL(x) #x
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1044|      0|  }
  ------------------
14274|    908|      "Offset is larger than total outputs");
14275|       |
14276|    908|  const size_t original_size = m_transfers.size();
14277|    908|  if (offset + output_array.size() > m_transfers.size())
  ------------------
  |  Branch (14277:7): [True: 45, False: 863]
  ------------------
14278|     45|    m_transfers.resize(offset + output_array.size());
14279|    863|  else if (num_outputs < m_transfers.size())
  ------------------
  |  Branch (14279:12): [True: 104, False: 759]
  ------------------
14280|    104|    m_transfers.resize(num_outputs);
14281|       |
14282|  1.68k|  for (size_t i = 0; i < output_array.size(); ++i)
  ------------------
  |  Branch (14282:22): [True: 778, False: 908]
  ------------------
14283|    778|  {
14284|    778|    transfer_details td = output_array[i];
14285|       |
14286|       |    // skip those we've already imported, or which have different data
14287|    778|    if (i + offset < original_size)
  ------------------
  |  Branch (14287:9): [True: 744, False: 34]
  ------------------
14288|    744|    {
14289|       |      // compare the data used to create the key image below
14290|    744|      const transfer_details &org_td = m_transfers[i + offset];
14291|    744|      if (!org_td.m_key_image_known)
  ------------------
  |  Branch (14291:11): [True: 558, False: 186]
  ------------------
14292|    558|        goto process;
14293|    186|#define CMPF(f) if (!(td.f == org_td.f)) goto process
14294|    186|      CMPF(m_txid);
  ------------------
  |  |14293|    186|#define CMPF(f) if (!(td.f == org_td.f)) goto process
  |  |  ------------------
  |  |  |  Branch (14293:21): [True: 128, False: 58]
  |  |  ------------------
  ------------------
14295|     58|      CMPF(m_key_image);
  ------------------
  |  |14293|     58|#define CMPF(f) if (!(td.f == org_td.f)) goto process
  |  |  ------------------
  |  |  |  Branch (14293:21): [True: 8, False: 50]
  |  |  ------------------
  ------------------
14296|     50|      CMPF(m_internal_output_index);
  ------------------
  |  |14293|     50|#define CMPF(f) if (!(td.f == org_td.f)) goto process
  |  |  ------------------
  |  |  |  Branch (14293:21): [True: 39, False: 11]
  |  |  ------------------
  ------------------
14297|     11|#undef CMPF
14298|     11|      if (!(get_transaction_prefix_hash(td.m_tx) == get_transaction_prefix_hash(org_td.m_tx)))
  ------------------
  |  Branch (14298:11): [True: 11, False: 0]
  ------------------
14299|     11|        goto process;
14300|       |
14301|       |      // copy anyway, since the comparison does not include ancillary fields which may have changed
14302|      0|      m_transfers[i + offset] = std::move(td);
14303|      0|      continue;
14304|     11|    }
14305|       |
14306|    778|process:
14307|       |
14308|       |    // the hot wallet wouldn't have known about key images (except if we already exported them)
14309|    778|    cryptonote::keypair in_ephemeral;
14310|       |
14311|    778|    THROW_WALLET_EXCEPTION_IF(td.m_tx.vout.empty(), error::wallet_internal_error, "tx with no outputs at index " + boost::lexical_cast<std::string>(i + offset));
  ------------------
  |  | 1040|    778|  if (cond)                                                                                                 \
  |  |  ------------------
  |  |  |  Branch (1040:7): [True: 116, False: 662]
  |  |  ------------------
  |  | 1041|    778|  {                                                                                                         \
  |  | 1042|    116|    LOG_ERROR(#cond << ". THROW EXCEPTION: " << #err_type);                                                 \
  |  |  ------------------
  |  |  |  |  100|    116|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|    116|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|    116|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|    116|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|    116|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|    116|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 116]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|    116|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1043|    116|    tools::error::throw_wallet_ex<err_type>(std::string(__FILE__ ":" STRINGIZE(__LINE__)), ## __VA_ARGS__); \
  |  |  ------------------
  |  |  |  | 1031|    116|#define STRINGIZE(x) STRINGIZE_DETAIL(x)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1030|    116|#define STRINGIZE_DETAIL(x) #x
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1044|    116|  }
  ------------------
14312|    778|    crypto::public_key tx_pub_key = get_tx_pub_key_from_received_outs(td);
14313|    778|    const std::vector<crypto::public_key> additional_tx_pub_keys = get_additional_tx_pub_keys_from_extra(td.m_tx);
14314|       |
14315|    778|    THROW_WALLET_EXCEPTION_IF(td.m_internal_output_index >= td.m_tx.vout.size(),
  ------------------
  |  | 1040|    778|  if (cond)                                                                                                 \
  |  |  ------------------
  |  |  |  Branch (1040:7): [True: 259, False: 519]
  |  |  ------------------
  |  | 1041|    778|  {                                                                                                         \
  |  | 1042|    259|    LOG_ERROR(#cond << ". THROW EXCEPTION: " << #err_type);                                                 \
  |  |  ------------------
  |  |  |  |  100|    259|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|    259|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|    259|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|    259|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|    259|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|    259|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 259]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|    259|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1043|    259|    tools::error::throw_wallet_ex<err_type>(std::string(__FILE__ ":" STRINGIZE(__LINE__)), ## __VA_ARGS__); \
  |  |  ------------------
  |  |  |  | 1031|    259|#define STRINGIZE(x) STRINGIZE_DETAIL(x)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1030|    259|#define STRINGIZE_DETAIL(x) #x
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1044|    259|  }
  ------------------
14316|    778|        error::wallet_internal_error, "Internal index is out of range");
14317|    778|    crypto::public_key out_key = td.get_public_key();
14318|    778|    if (should_expand(td.m_subaddr_index))
  ------------------
  |  Branch (14318:9): [True: 17, False: 761]
  ------------------
14319|     17|      create_one_off_subaddress(td.m_subaddr_index);
14320|    778|    bool r = cryptonote::generate_key_image_helper(m_account.get_keys(), m_subaddresses, out_key, tx_pub_key, additional_tx_pub_keys, td.m_internal_output_index, in_ephemeral, td.m_key_image, m_account.get_device());
14321|    778|    THROW_WALLET_EXCEPTION_IF(!r, error::wallet_internal_error, "Failed to generate key image");
  ------------------
  |  | 1040|    778|  if (cond)                                                                                                 \
  |  |  ------------------
  |  |  |  Branch (1040:7): [True: 141, False: 637]
  |  |  ------------------
  |  | 1041|    778|  {                                                                                                         \
  |  | 1042|    141|    LOG_ERROR(#cond << ". THROW EXCEPTION: " << #err_type);                                                 \
  |  |  ------------------
  |  |  |  |  100|    141|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|    141|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|    141|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|    141|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|    141|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|    141|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 141]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|    141|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1043|    141|    tools::error::throw_wallet_ex<err_type>(std::string(__FILE__ ":" STRINGIZE(__LINE__)), ## __VA_ARGS__); \
  |  |  ------------------
  |  |  |  | 1031|    141|#define STRINGIZE(x) STRINGIZE_DETAIL(x)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1030|    141|#define STRINGIZE_DETAIL(x) #x
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1044|    141|  }
  ------------------
14322|    778|    if (should_expand(td.m_subaddr_index))
  ------------------
  |  Branch (14322:9): [True: 0, False: 778]
  ------------------
14323|      0|      expand_subaddresses(td.m_subaddr_index);
14324|    778|    td.m_key_image_known = true;
14325|    778|    td.m_key_image_request = true;
14326|    778|    td.m_key_image_partial = false;
14327|    778|    THROW_WALLET_EXCEPTION_IF(in_ephemeral.pub != out_key,
  ------------------
  |  | 1040|    778|  if (cond)                                                                                                 \
  |  |  ------------------
  |  |  |  Branch (1040:7): [True: 0, False: 778]
  |  |  ------------------
  |  | 1041|    778|  {                                                                                                         \
  |  | 1042|      0|    LOG_ERROR(#cond << ". THROW EXCEPTION: " << #err_type);                                                 \
  |  |  ------------------
  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1043|      0|    tools::error::throw_wallet_ex<err_type>(std::string(__FILE__ ":" STRINGIZE(__LINE__)), ## __VA_ARGS__); \
  |  |  ------------------
  |  |  |  | 1031|      0|#define STRINGIZE(x) STRINGIZE_DETAIL(x)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1030|      0|#define STRINGIZE_DETAIL(x) #x
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1044|      0|  }
  ------------------
14328|    778|        error::wallet_internal_error, "key_image generated ephemeral public key not matched with output_key at index " + boost::lexical_cast<std::string>(i + offset));
14329|       |
14330|    778|    m_key_images[td.m_key_image] = i + offset;
14331|    778|    m_pub_keys[td.get_public_key()] = i + offset;
14332|    778|    m_transfers[i + offset] = std::move(td);
14333|    778|  }
14334|       |
14335|    908|  return m_transfers.size();
14336|    908|}
_ZN5tools7wallet214import_outputsERKNSt3__15tupleIJmmNS1_6vectorINS0_25exported_transfer_detailsENS1_9allocatorIS4_EEEEEEE:
14339|  1.18k|{
14340|  1.18k|  PERF_TIMER(import_outputs);
  ------------------
  |  |   82|  1.18k|#define PERF_TIMER(name) PERF_TIMER_UNIT(name, 1000000)
  |  |  ------------------
  |  |  |  |   80|  1.18k|#define PERF_TIMER_UNIT(name, unit) tools::LoggingPerformanceTimer PERF_TIMER_NAME(name)(#name, "perf." MONERO_DEFAULT_LOG_CATEGORY, unit, tools::performance_timer_log_level)
  |  |  |  |  ------------------
  |  |  |  |  |  |   79|  1.18k|#define PERF_TIMER_NAME(name) pt_##name
  |  |  |  |  ------------------
  |  |  |  |               #define PERF_TIMER_UNIT(name, unit) tools::LoggingPerformanceTimer PERF_TIMER_NAME(name)(#name, "perf." MONERO_DEFAULT_LOG_CATEGORY, unit, tools::performance_timer_log_level)
  |  |  |  |  ------------------
  |  |  |  |  |  |  105|  1.18k|#define MONERO_DEFAULT_LOG_CATEGORY "wallet.wallet2"
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
14341|       |
14342|  1.18k|  THROW_WALLET_EXCEPTION_IF(m_has_ever_refreshed_from_node, error::wallet_internal_error,
  ------------------
  |  | 1040|  1.18k|  if (cond)                                                                                                 \
  |  |  ------------------
  |  |  |  Branch (1040:7): [True: 0, False: 1.18k]
  |  |  ------------------
  |  | 1041|  1.18k|  {                                                                                                         \
  |  | 1042|      0|    LOG_ERROR(#cond << ". THROW EXCEPTION: " << #err_type);                                                 \
  |  |  ------------------
  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1043|      0|    tools::error::throw_wallet_ex<err_type>(std::string(__FILE__ ":" STRINGIZE(__LINE__)), ## __VA_ARGS__); \
  |  |  ------------------
  |  |  |  | 1031|      0|#define STRINGIZE(x) STRINGIZE_DETAIL(x)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1030|      0|#define STRINGIZE_DETAIL(x) #x
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1044|      0|  }
  ------------------
14343|  1.18k|      "Hot wallets cannot import outputs");
14344|       |
14345|       |  // we can now import piecemeal
14346|  1.18k|  const size_t offset = std::get<0>(outputs);
14347|  1.18k|  const size_t num_outputs = std::get<1>(outputs);
14348|  1.18k|  const std::vector<tools::wallet2::exported_transfer_details> &output_array = std::get<2>(outputs);
14349|       |
14350|  1.18k|  THROW_WALLET_EXCEPTION_IF(offset > m_transfers.size(), error::wallet_internal_error,
  ------------------
  |  | 1040|  1.18k|  if (cond)                                                                                                 \
  |  |  ------------------
  |  |  |  Branch (1040:7): [True: 93, False: 1.08k]
  |  |  ------------------
  |  | 1041|  1.18k|  {                                                                                                         \
  |  | 1042|     93|    LOG_ERROR(#cond << ". THROW EXCEPTION: " << #err_type);                                                 \
  |  |  ------------------
  |  |  |  |  100|     93|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|     93|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|     93|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|     93|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|     93|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|     93|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 93]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|     93|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1043|     93|    tools::error::throw_wallet_ex<err_type>(std::string(__FILE__ ":" STRINGIZE(__LINE__)), ## __VA_ARGS__); \
  |  |  ------------------
  |  |  |  | 1031|     93|#define STRINGIZE(x) STRINGIZE_DETAIL(x)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1030|     93|#define STRINGIZE_DETAIL(x) #x
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1044|     93|  }
  ------------------
14351|  1.18k|      "Imported outputs omit more outputs that we know of. Try using export_outputs all.");
14352|       |
14353|  1.18k|  THROW_WALLET_EXCEPTION_IF(offset + output_array.size() > num_outputs, error::wallet_internal_error,
  ------------------
  |  | 1040|  1.18k|  if (cond)                                                                                                 \
  |  |  ------------------
  |  |  |  Branch (1040:7): [True: 12, False: 1.16k]
  |  |  ------------------
  |  | 1041|  1.18k|  {                                                                                                         \
  |  | 1042|     12|    LOG_ERROR(#cond << ". THROW EXCEPTION: " << #err_type);                                                 \
  |  |  ------------------
  |  |  |  |  100|     12|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|     12|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|     12|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|     12|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|     12|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|     12|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 12]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|     12|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1043|     12|    tools::error::throw_wallet_ex<err_type>(std::string(__FILE__ ":" STRINGIZE(__LINE__)), ## __VA_ARGS__); \
  |  |  ------------------
  |  |  |  | 1031|     12|#define STRINGIZE(x) STRINGIZE_DETAIL(x)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1030|     12|#define STRINGIZE_DETAIL(x) #x
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1044|     12|  }
  ------------------
14354|  1.18k|      "Offset is larger than total outputs");
14355|       |
14356|  1.18k|  const size_t original_size = m_transfers.size();
14357|  1.18k|  if (offset + output_array.size() > m_transfers.size())
  ------------------
  |  Branch (14357:7): [True: 130, False: 1.05k]
  ------------------
14358|    130|    m_transfers.resize(offset + output_array.size());
14359|  1.05k|  else if (num_outputs < m_transfers.size())
  ------------------
  |  Branch (14359:12): [True: 54, False: 997]
  ------------------
14360|     54|    m_transfers.resize(num_outputs);
14361|       |
14362|  2.27k|  for (size_t i = 0; i < output_array.size(); ++i)
  ------------------
  |  Branch (14362:22): [True: 1.09k, False: 1.18k]
  ------------------
14363|  1.09k|  {
14364|  1.09k|    exported_transfer_details etd = output_array[i];
14365|  1.09k|    transfer_details &td = m_transfers[i + offset];
14366|       |
14367|       |    // setup td with "cheap" loaded data
14368|  1.09k|    td.m_block_height = 0;
14369|  1.09k|    td.m_txid = crypto::null_hash;
14370|  1.09k|    td.m_global_output_index = etd.m_global_output_index;
14371|  1.09k|    td.m_spent = etd.m_flags.m_spent;
14372|  1.09k|    td.m_frozen = etd.m_flags.m_frozen;
14373|  1.09k|    td.m_spent_height = 0;
14374|  1.09k|    td.m_mask = rct::identity();
14375|  1.09k|    td.m_amount = etd.m_amount;
14376|  1.09k|    td.m_rct = etd.m_flags.m_rct;
14377|  1.09k|    td.m_key_image_known = etd.m_flags.m_key_image_known;
14378|  1.09k|    td.m_key_image_request = etd.m_flags.m_key_image_request;
14379|  1.09k|    td.m_key_image_partial = false;
14380|  1.09k|    td.m_subaddr_index.major = etd.m_subaddr_index_major;
14381|  1.09k|    td.m_subaddr_index.minor = etd.m_subaddr_index_minor;
14382|       |
14383|       |    // skip those we've already imported, or which have different data
14384|  1.09k|    if (i + offset < original_size)
  ------------------
  |  Branch (14384:9): [True: 1.03k, False: 52]
  ------------------
14385|  1.03k|    {
14386|  1.03k|      bool needs_processing = false;
14387|  1.03k|      if (!td.m_key_image_known)
  ------------------
  |  Branch (14387:11): [True: 537, False: 502]
  ------------------
14388|    537|        needs_processing = true;
14389|    502|      else if (!(etd.m_internal_output_index == td.m_internal_output_index))
  ------------------
  |  Branch (14389:16): [True: 408, False: 94]
  ------------------
14390|    408|        needs_processing = true;
14391|     94|      else if (!(etd.m_pubkey == td.get_public_key()))
  ------------------
  |  Branch (14391:16): [True: 61, False: 33]
  ------------------
14392|     61|        needs_processing = true;
14393|       |
14394|  1.03k|      if (!needs_processing)
  ------------------
  |  Branch (14394:11): [True: 15, False: 1.02k]
  ------------------
14395|     15|        continue;
14396|  1.03k|    }
14397|       |
14398|       |    // construct a synthetix tx prefix that has the info we'll need: the output with its pubkey, the tx pubkey in extra
14399|  1.07k|    td.m_tx = {};
14400|       |
14401|  1.07k|    THROW_WALLET_EXCEPTION_IF(etd.m_internal_output_index >= 65536, error::wallet_internal_error, "internal output index seems outrageously high, rejecting");
  ------------------
  |  | 1040|  1.07k|  if (cond)                                                                                                 \
  |  |  ------------------
  |  |  |  Branch (1040:7): [True: 161, False: 915]
  |  |  ------------------
  |  | 1041|  1.07k|  {                                                                                                         \
  |  | 1042|    161|    LOG_ERROR(#cond << ". THROW EXCEPTION: " << #err_type);                                                 \
  |  |  ------------------
  |  |  |  |  100|    161|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|    161|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|    161|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|    161|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|    161|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|    161|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 161]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|    161|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1043|    161|    tools::error::throw_wallet_ex<err_type>(std::string(__FILE__ ":" STRINGIZE(__LINE__)), ## __VA_ARGS__); \
  |  |  ------------------
  |  |  |  | 1031|    161|#define STRINGIZE(x) STRINGIZE_DETAIL(x)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1030|    161|#define STRINGIZE_DETAIL(x) #x
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1044|    161|  }
  ------------------
14402|  1.07k|    td.m_internal_output_index = etd.m_internal_output_index;
14403|  1.07k|    cryptonote::txout_to_key tk;
14404|  1.07k|    tk.key = etd.m_pubkey;
14405|  1.07k|    cryptonote::tx_out out;
14406|  1.07k|    out.amount = etd.m_amount;
14407|  1.07k|    out.target = tk;
14408|  1.07k|    td.m_tx.vout.resize(etd.m_internal_output_index);
14409|  1.07k|    td.m_tx.vout.push_back(out);
14410|       |
14411|  1.07k|    td.m_pk_index = 0;
14412|  1.07k|    add_tx_pub_key_to_extra(td.m_tx, etd.m_tx_pubkey);
14413|  1.07k|    if (!etd.m_additional_tx_keys.empty())
  ------------------
  |  Branch (14413:9): [True: 178, False: 898]
  ------------------
14414|    178|      add_additional_tx_pub_keys_to_extra(td.m_tx.extra, etd.m_additional_tx_keys);
14415|       |
14416|       |    // the hot wallet wouldn't have known about key images (except if we already exported them)
14417|  1.07k|    cryptonote::keypair in_ephemeral;
14418|       |
14419|  1.07k|    const crypto::public_key &tx_pub_key = etd.m_tx_pubkey;
14420|  1.07k|    const std::vector<crypto::public_key> &additional_tx_pub_keys = etd.m_additional_tx_keys;
14421|  1.07k|    const crypto::public_key& out_key = etd.m_pubkey;
14422|  1.07k|    if (should_expand(td.m_subaddr_index))
  ------------------
  |  Branch (14422:9): [True: 694, False: 382]
  ------------------
14423|    694|      create_one_off_subaddress(td.m_subaddr_index);
14424|  1.07k|    bool r = cryptonote::generate_key_image_helper(m_account.get_keys(), m_subaddresses, out_key, tx_pub_key, additional_tx_pub_keys, td.m_internal_output_index, in_ephemeral, td.m_key_image, m_account.get_device());
14425|  1.07k|    THROW_WALLET_EXCEPTION_IF(!r, error::wallet_internal_error, "Failed to generate key image");
  ------------------
  |  | 1040|  1.07k|  if (cond)                                                                                                 \
  |  |  ------------------
  |  |  |  Branch (1040:7): [True: 897, False: 179]
  |  |  ------------------
  |  | 1041|  1.07k|  {                                                                                                         \
  |  | 1042|    897|    LOG_ERROR(#cond << ". THROW EXCEPTION: " << #err_type);                                                 \
  |  |  ------------------
  |  |  |  |  100|    897|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|    897|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|    897|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|    897|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|    897|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|    897|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 897]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|    897|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1043|    897|    tools::error::throw_wallet_ex<err_type>(std::string(__FILE__ ":" STRINGIZE(__LINE__)), ## __VA_ARGS__); \
  |  |  ------------------
  |  |  |  | 1031|    897|#define STRINGIZE(x) STRINGIZE_DETAIL(x)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1030|    897|#define STRINGIZE_DETAIL(x) #x
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1044|    897|  }
  ------------------
14426|  1.07k|    if (should_expand(td.m_subaddr_index))
  ------------------
  |  Branch (14426:9): [True: 0, False: 1.07k]
  ------------------
14427|      0|      expand_subaddresses(td.m_subaddr_index);
14428|  1.07k|    td.m_key_image_known = true;
14429|  1.07k|    td.m_key_image_request = true;
14430|  1.07k|    td.m_key_image_partial = false;
14431|  1.07k|    THROW_WALLET_EXCEPTION_IF(in_ephemeral.pub != out_key,
  ------------------
  |  | 1040|  1.07k|  if (cond)                                                                                                 \
  |  |  ------------------
  |  |  |  Branch (1040:7): [True: 0, False: 1.07k]
  |  |  ------------------
  |  | 1041|  1.07k|  {                                                                                                         \
  |  | 1042|      0|    LOG_ERROR(#cond << ". THROW EXCEPTION: " << #err_type);                                                 \
  |  |  ------------------
  |  |  |  |  100|      0|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1043|      0|    tools::error::throw_wallet_ex<err_type>(std::string(__FILE__ ":" STRINGIZE(__LINE__)), ## __VA_ARGS__); \
  |  |  ------------------
  |  |  |  | 1031|      0|#define STRINGIZE(x) STRINGIZE_DETAIL(x)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1030|      0|#define STRINGIZE_DETAIL(x) #x
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1044|      0|  }
  ------------------
14432|  1.07k|        error::wallet_internal_error, "key_image generated ephemeral public key not matched with output_key at index " + boost::lexical_cast<std::string>(i + offset));
14433|       |
14434|  1.07k|    m_key_images[td.m_key_image] = i + offset;
14435|  1.07k|    m_pub_keys[td.get_public_key()] = i + offset;
14436|  1.07k|  }
14437|       |
14438|  1.18k|  return m_transfers.size();
14439|  1.18k|}
_ZNK5tools7wallet27encryptEPKcmRKN4epee7mlockedINS_8scrubbedIN6crypto9ec_scalarEEEEEb:
14872|  5.59k|{
14873|  5.59k|  crypto::chacha_key key;
14874|  5.59k|  crypto::generate_chacha_key(&skey, sizeof(skey), key, m_kdf_rounds);
14875|  5.59k|  std::string ciphertext;
14876|  5.59k|  crypto::chacha_iv iv = crypto::rand<crypto::chacha_iv>();
14877|  5.59k|  ciphertext.resize(len + sizeof(iv) + (authenticated ? sizeof(crypto::signature) : 0));
  ------------------
  |  Branch (14877:41): [True: 5.59k, False: 0]
  ------------------
14878|  5.59k|  crypto::chacha20(plaintext, len, key, iv, &ciphertext[sizeof(iv)]);
14879|  5.59k|  memcpy(&ciphertext[0], &iv, sizeof(iv));
14880|  5.59k|  if (authenticated)
  ------------------
  |  Branch (14880:7): [True: 5.59k, False: 0]
  ------------------
14881|  5.59k|  {
14882|  5.59k|    crypto::hash hash;
14883|  5.59k|    crypto::cn_fast_hash(ciphertext.data(), ciphertext.size() - sizeof(signature), hash);
14884|  5.59k|    crypto::public_key pkey;
14885|  5.59k|    crypto::secret_key_to_public_key(skey, pkey);
14886|  5.59k|    crypto::signature &signature = *(crypto::signature*)&ciphertext[ciphertext.size() - sizeof(crypto::signature)];
14887|  5.59k|    crypto::generate_signature(hash, pkey, skey, signature);
14888|  5.59k|  }
14889|  5.59k|  return ciphertext;
14890|  5.59k|}
_ZNK5tools7wallet27encryptERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKN4epee7mlockedINS_8scrubbedIN6crypto9ec_scalarEEEEEb:
14898|  5.59k|{
14899|  5.59k|  return encrypt(plaintext.data(), plaintext.size(), skey, authenticated);
14900|  5.59k|}
_ZNK5tools7wallet228encrypt_with_view_secret_keyERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEb:
14908|  5.59k|{
14909|  5.59k|  return encrypt(plaintext, get_account().get_keys().m_view_secret_key, authenticated);
14910|  5.59k|}
_ZNK5tools7wallet216generate_genesisERN10cryptonote5blockE:
15264|      1|void wallet2::generate_genesis(cryptonote::block& b) const {
15265|      1|  cryptonote::generate_genesis_block(b, get_config(m_nettype).GENESIS_TX, get_config(m_nettype).GENESIS_NONCE);
15266|      1|}
_ZNK5tools7wallet212save_to_fileERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_b:
15337|  5.59k|{
15338|  5.59k|  if (is_printable || m_export_format == ExportFormat::Binary)
  ------------------
  |  Branch (15338:7): [True: 0, False: 5.59k]
  |  Branch (15338:23): [True: 5.59k, False: 0]
  ------------------
15339|  5.59k|  {
15340|  5.59k|    return epee::file_io_utils::save_string_to_file(path_to_file, raw);
15341|  5.59k|  }
15342|       |
15343|      0|  FILE *fp = fopen(path_to_file.c_str(), "w+");
15344|      0|  if (!fp)
  ------------------
  |  Branch (15344:7): [True: 0, False: 0]
  ------------------
15345|      0|  {
15346|      0|    MERROR("Failed to open wallet file for writing: " << path_to_file << ": " << strerror(errno));
  ------------------
  |  |   75|      0|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  ------------------
  |  |  |  |   53|      0|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   49|      0|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   43|      0|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |   44|      0|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |   47|      0|  } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
15347|      0|    return false;
15348|      0|  }
15349|       |
15350|       |  // Save the result b/c we need to close the fp before returning success/failure.
15351|      0|  int write_result = PEM_write(fp, ASCII_OUTPUT_MAGIC.c_str(), "", (const unsigned char *) raw.c_str(), raw.length());
15352|      0|  fclose(fp);
15353|       |
15354|      0|  if (write_result == 0)
  ------------------
  |  Branch (15354:7): [True: 0, False: 0]
  ------------------
15355|      0|  {
15356|      0|    return false;
15357|      0|  }
15358|      0|  else
15359|      0|  {
15360|      0|    return true;
15361|      0|  }
15362|      0|}
wallet2.cpp:_ZN12_GLOBAL__N_126get_subaddress_clamped_sumEjj:
  943|      2|{
  944|      2|  static constexpr uint32_t uint32_max = std::numeric_limits<uint32_t>::max();
  945|      2|  if (idx > uint32_max - extra)
  ------------------
  |  Branch (945:7): [True: 0, False: 2]
  ------------------
  946|      0|    return uint32_max;
  947|      2|  return idx + extra;
  948|      2|}
wallet2.cpp:_ZN12_GLOBAL__N_116derive_cache_keyERKN4epee7mlockedIN5tools8scrubbedINSt3__15arrayIhLm32EEEEEEEh:
 1014|      1|{
 1015|      1|  static_assert(HASH_SIZE == sizeof(crypto::chacha_key), "Mismatched sizes of hash and chacha key");
 1016|       |
 1017|      1|  crypto::chacha_key cache_key;
 1018|      1|  epee::mlocked<tools::scrubbed_arr<char, HASH_SIZE+1>> cache_key_data;
 1019|      1|  memcpy(cache_key_data.data(), &keys_data_key, HASH_SIZE);
 1020|      1|  cache_key_data[HASH_SIZE] = domain_separator;
 1021|      1|  cn_fast_hash(cache_key_data.data(), HASH_SIZE+1, (crypto::hash&) cache_key);
 1022|       |
 1023|      1|  return cache_key;
 1024|      1|}
wallet2.cpp:_ZN12_GLOBAL__N_121do_prepare_file_namesERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEERS6_S9_S9_:
  284|      1|{
  285|      1|  keys_file = file_path;
  286|      1|  wallet_file = file_path;
  287|      1|  if(string_tools::get_extension(keys_file) == "keys")
  ------------------
  |  Branch (287:6): [True: 0, False: 1]
  ------------------
  288|      0|  {//provided keys file name
  289|      0|    wallet_file = string_tools::cut_off_extension(wallet_file);
  290|      0|  }else
  291|      1|  {//provided wallet file name
  292|      1|    keys_file += ".keys";
  293|      1|  }
  294|      1|  mms_file = file_path + ".mms";
  295|      1|}

_ZN5tools7wallet215unsigned_tx_set19do_serialize_objectILb0E14binary_archiveEEbRT0_IXT_EE:
  687|  9.74k|      BEGIN_SERIALIZE_OBJECT()
  ------------------
  |  |  184|  9.74k|  bool do_serialize_object(Archive<W> &ar){
  ------------------
  688|  9.74k|        VERSION_FIELD(2)
  ------------------
  |  |  289|  9.74k|  uint32_t version = v;				\
  |  |  290|  9.74k|  do {						\
  |  |  291|  9.74k|    ar.tag("version");				\
  |  |  292|  9.74k|    ar.serialize_varint(version);		\
  |  |  293|  9.74k|    if (!ar.good()) return false;		\
  |  |  ------------------
  |  |  |  Branch (293:9): [True: 22, False: 9.72k]
  |  |  ------------------
  |  |  294|  9.74k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (294:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  689|  9.72k|        FIELD(txes)
  ------------------
  |  |  226|  9.72k|  do {							\
  |  |  227|  9.72k|    ar.tag(#f);						\
  |  |  228|  9.72k|    bool r = do_serialize(ar, f);			\
  |  |  229|  9.72k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 3.20k, False: 6.52k]
  |  |  |  Branch (229:15): [True: 0, False: 6.52k]
  |  |  ------------------
  |  |  230|  9.72k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  690|  6.52k|        if (version == 0)
  ------------------
  |  Branch (690:13): [True: 4.01k, False: 2.51k]
  ------------------
  691|  4.01k|        {
  692|  4.01k|          std::pair<size_t, wallet2::transfer_container> v0_transfers;
  693|  4.01k|          FIELD(v0_transfers);
  ------------------
  |  |  226|  4.01k|  do {							\
  |  |  227|  4.01k|    ar.tag(#f);						\
  |  |  228|  4.01k|    bool r = do_serialize(ar, f);			\
  |  |  229|  4.01k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 3.08k, False: 927]
  |  |  |  Branch (229:15): [True: 0, False: 927]
  |  |  ------------------
  |  |  230|  4.01k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  694|    927|          std::get<0>(transfers) = std::get<0>(v0_transfers);
  695|    927|          std::get<1>(transfers) = std::get<0>(v0_transfers) + std::get<1>(v0_transfers).size();
  696|    927|          std::get<2>(transfers) = std::get<1>(v0_transfers);
  697|    927|          return true;
  698|  4.01k|        }
  699|  2.51k|        if (version == 1)
  ------------------
  |  Branch (699:13): [True: 1.38k, False: 1.12k]
  ------------------
  700|  1.38k|        {
  701|  1.38k|          std::pair<size_t, std::vector<wallet2::exported_transfer_details>> v1_transfers;
  702|  1.38k|          FIELD(v1_transfers);
  ------------------
  |  |  226|  1.38k|  do {							\
  |  |  227|  1.38k|    ar.tag(#f);						\
  |  |  228|  1.38k|    bool r = do_serialize(ar, f);			\
  |  |  229|  1.38k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 508, False: 873]
  |  |  |  Branch (229:15): [True: 0, False: 873]
  |  |  ------------------
  |  |  230|  1.38k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  703|    873|          std::get<0>(new_transfers) = std::get<0>(v1_transfers);
  704|    873|          std::get<1>(new_transfers) = std::get<0>(v1_transfers) + std::get<1>(v1_transfers).size();
  705|    873|          std::get<2>(new_transfers) = std::get<1>(v1_transfers);
  706|    873|          return true;
  707|  1.38k|        }
  708|       |
  709|  1.12k|        FIELD(new_transfers)
  ------------------
  |  |  226|  1.12k|  do {							\
  |  |  227|  1.12k|    ar.tag(#f);						\
  |  |  228|  1.12k|    bool r = do_serialize(ar, f);			\
  |  |  229|  1.12k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 1.06k, False: 63]
  |  |  |  Branch (229:15): [True: 0, False: 63]
  |  |  ------------------
  |  |  230|  1.12k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  710|     63|      END_SERIALIZE()
  ------------------
  |  |  207|     63|  return ar.good();				\
  |  |  208|  1.12k|  }
  ------------------
_ZN5tools7wallet220tx_construction_data19do_serialize_objectILb0E14binary_archiveEEbRT0_IXT_EE:
  570|  9.02k|      BEGIN_SERIALIZE_OBJECT()
  ------------------
  |  |  184|  9.02k|  bool do_serialize_object(Archive<W> &ar){
  ------------------
  571|  9.02k|        FIELD(sources)
  ------------------
  |  |  226|  9.02k|  do {							\
  |  |  227|  9.02k|    ar.tag(#f);						\
  |  |  228|  9.02k|    bool r = do_serialize(ar, f);			\
  |  |  229|  9.02k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 984, False: 8.04k]
  |  |  |  Branch (229:15): [True: 0, False: 8.04k]
  |  |  ------------------
  |  |  230|  9.02k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  572|  8.04k|        FIELD(change_dts)
  ------------------
  |  |  226|  8.04k|  do {							\
  |  |  227|  8.04k|    ar.tag(#f);						\
  |  |  228|  8.04k|    bool r = do_serialize(ar, f);			\
  |  |  229|  8.04k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 1.36k, False: 6.67k]
  |  |  |  Branch (229:15): [True: 0, False: 6.67k]
  |  |  ------------------
  |  |  230|  8.04k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  573|  6.67k|        FIELD(splitted_dsts)
  ------------------
  |  |  226|  6.67k|  do {							\
  |  |  227|  6.67k|    ar.tag(#f);						\
  |  |  228|  6.67k|    bool r = do_serialize(ar, f);			\
  |  |  229|  6.67k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 281, False: 6.39k]
  |  |  |  Branch (229:15): [True: 0, False: 6.39k]
  |  |  ------------------
  |  |  230|  6.67k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  574|  6.39k|        FIELD(selected_transfers)
  ------------------
  |  |  226|  6.39k|  do {							\
  |  |  227|  6.39k|    ar.tag(#f);						\
  |  |  228|  6.39k|    bool r = do_serialize(ar, f);			\
  |  |  229|  6.39k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 17, False: 6.37k]
  |  |  |  Branch (229:15): [True: 0, False: 6.37k]
  |  |  ------------------
  |  |  230|  6.39k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  575|  6.37k|        FIELD(extra)
  ------------------
  |  |  226|  6.37k|  do {							\
  |  |  227|  6.37k|    ar.tag(#f);						\
  |  |  228|  6.37k|    bool r = do_serialize(ar, f);			\
  |  |  229|  6.37k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 4, False: 6.37k]
  |  |  |  Branch (229:15): [True: 0, False: 6.37k]
  |  |  ------------------
  |  |  230|  6.37k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  576|  6.37k|        FIELD(unlock_time)
  ------------------
  |  |  226|  6.37k|  do {							\
  |  |  227|  6.37k|    ar.tag(#f);						\
  |  |  228|  6.37k|    bool r = do_serialize(ar, f);			\
  |  |  229|  6.37k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 6.37k]
  |  |  |  Branch (229:15): [True: 19, False: 6.35k]
  |  |  ------------------
  |  |  230|  6.37k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  577|       |
  578|       |        // converted `use_rct` field into construction_flags when view tags
  579|       |        // were introduced to maintain backwards compatibility
  580|  6.35k|        if (!typename Archive<W>::is_saving())
  ------------------
  |  Branch (580:13): [Folded - Ignored]
  ------------------
  581|  6.35k|        {
  582|  6.35k|          FIELD_N("use_rct", construction_flags)
  ------------------
  |  |  215|  6.35k|  do {							\
  |  |  216|  6.35k|    ar.tag(t);						\
  |  |  217|  6.35k|    bool r = do_serialize(ar, f VA_ARGS_COMMAPREFIX(__VA_ARGS__)); \
  |  |  218|  6.35k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (218:9): [True: 0, False: 6.35k]
  |  |  |  Branch (218:15): [True: 9, False: 6.34k]
  |  |  ------------------
  |  |  219|  6.35k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (219:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  583|  6.34k|          use_rct = (construction_flags & _use_rct) > 0;
  584|  6.34k|          use_view_tags = (construction_flags & _use_view_tags) > 0;
  585|  6.34k|        }
  586|      0|        else
  587|      0|        {
  588|      0|          construction_flags = 0;
  589|      0|          if (use_rct)
  ------------------
  |  Branch (589:15): [True: 0, False: 0]
  ------------------
  590|      0|            construction_flags ^= _use_rct;
  591|      0|          if (use_view_tags)
  ------------------
  |  Branch (591:15): [True: 0, False: 0]
  ------------------
  592|      0|            construction_flags ^= _use_view_tags;
  593|       |
  594|      0|          FIELD_N("use_rct", construction_flags)
  ------------------
  |  |  215|      0|  do {							\
  |  |  216|      0|    ar.tag(t);						\
  |  |  217|      0|    bool r = do_serialize(ar, f VA_ARGS_COMMAPREFIX(__VA_ARGS__)); \
  |  |  218|      0|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (218:9): [True: 0, False: 0]
  |  |  |  Branch (218:15): [True: 0, False: 0]
  |  |  ------------------
  |  |  219|      0|  } while(0);
  |  |  ------------------
  |  |  |  Branch (219:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  595|      0|        }
  596|       |
  597|  6.34k|        FIELD(rct_config)
  ------------------
  |  |  226|  6.34k|  do {							\
  |  |  227|  6.34k|    ar.tag(#f);						\
  |  |  228|  6.34k|    bool r = do_serialize(ar, f);			\
  |  |  229|  6.34k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 40, False: 6.30k]
  |  |  |  Branch (229:15): [True: 0, False: 6.30k]
  |  |  ------------------
  |  |  230|  6.34k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  598|  6.30k|        FIELD(dests)
  ------------------
  |  |  226|  6.30k|  do {							\
  |  |  227|  6.30k|    ar.tag(#f);						\
  |  |  228|  6.30k|    bool r = do_serialize(ar, f);			\
  |  |  229|  6.30k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 47, False: 6.25k]
  |  |  |  Branch (229:15): [True: 0, False: 6.25k]
  |  |  ------------------
  |  |  230|  6.30k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  599|  6.25k|        FIELD(subaddr_account)
  ------------------
  |  |  226|  6.25k|  do {							\
  |  |  227|  6.25k|    ar.tag(#f);						\
  |  |  228|  6.25k|    bool r = do_serialize(ar, f);			\
  |  |  229|  6.25k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 6.25k]
  |  |  |  Branch (229:15): [True: 82, False: 6.17k]
  |  |  ------------------
  |  |  230|  6.25k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  600|  6.17k|        FIELD(subaddr_indices)
  ------------------
  |  |  226|  6.17k|  do {							\
  |  |  227|  6.17k|    ar.tag(#f);						\
  |  |  228|  6.17k|    bool r = do_serialize(ar, f);			\
  |  |  229|  6.17k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 208, False: 5.96k]
  |  |  |  Branch (229:15): [True: 0, False: 5.96k]
  |  |  ------------------
  |  |  230|  6.17k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  601|  5.96k|      END_SERIALIZE()
  ------------------
  |  |  207|  5.96k|  return ar.good();				\
  |  |  208|  6.17k|  }
  ------------------
_ZN5tools7wallet216transfer_details19do_serialize_objectILb0E14binary_archiveEEbRT0_IXT_EE:
  366|  12.4k|      BEGIN_SERIALIZE_OBJECT()
  ------------------
  |  |  184|  12.4k|  bool do_serialize_object(Archive<W> &ar){
  ------------------
  367|  12.4k|        FIELD(m_block_height)
  ------------------
  |  |  226|  12.4k|  do {							\
  |  |  227|  12.4k|    ar.tag(#f);						\
  |  |  228|  12.4k|    bool r = do_serialize(ar, f);			\
  |  |  229|  12.4k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 12.4k]
  |  |  |  Branch (229:15): [True: 66, False: 12.4k]
  |  |  ------------------
  |  |  230|  12.4k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  368|  12.4k|        FIELD(m_tx)
  ------------------
  |  |  226|  12.4k|  do {							\
  |  |  227|  12.4k|    ar.tag(#f);						\
  |  |  228|  12.4k|    bool r = do_serialize(ar, f);			\
  |  |  229|  12.4k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 1.53k, False: 10.8k]
  |  |  |  Branch (229:15): [True: 0, False: 10.8k]
  |  |  ------------------
  |  |  230|  12.4k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  369|  10.8k|        FIELD(m_txid)
  ------------------
  |  |  226|  10.8k|  do {							\
  |  |  227|  10.8k|    ar.tag(#f);						\
  |  |  228|  10.8k|    bool r = do_serialize(ar, f);			\
  |  |  229|  10.8k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 10.8k]
  |  |  |  Branch (229:15): [True: 119, False: 10.7k]
  |  |  ------------------
  |  |  230|  10.8k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  370|  10.7k|        FIELD(m_internal_output_index)
  ------------------
  |  |  226|  10.7k|  do {							\
  |  |  227|  10.7k|    ar.tag(#f);						\
  |  |  228|  10.7k|    bool r = do_serialize(ar, f);			\
  |  |  229|  10.7k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 10.7k]
  |  |  |  Branch (229:15): [True: 14, False: 10.7k]
  |  |  ------------------
  |  |  230|  10.7k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  371|  10.7k|        FIELD(m_global_output_index)
  ------------------
  |  |  226|  10.7k|  do {							\
  |  |  227|  10.7k|    ar.tag(#f);						\
  |  |  228|  10.7k|    bool r = do_serialize(ar, f);			\
  |  |  229|  10.7k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 10.7k]
  |  |  |  Branch (229:15): [True: 20, False: 10.7k]
  |  |  ------------------
  |  |  230|  10.7k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  372|  10.7k|        FIELD(m_spent)
  ------------------
  |  |  226|  10.7k|  do {							\
  |  |  227|  10.7k|    ar.tag(#f);						\
  |  |  228|  10.7k|    bool r = do_serialize(ar, f);			\
  |  |  229|  10.7k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 10.7k]
  |  |  |  Branch (229:15): [True: 8, False: 10.7k]
  |  |  ------------------
  |  |  230|  10.7k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  373|  10.7k|        FIELD(m_frozen)
  ------------------
  |  |  226|  10.7k|  do {							\
  |  |  227|  10.7k|    ar.tag(#f);						\
  |  |  228|  10.7k|    bool r = do_serialize(ar, f);			\
  |  |  229|  10.7k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 10.7k]
  |  |  |  Branch (229:15): [True: 8, False: 10.7k]
  |  |  ------------------
  |  |  230|  10.7k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  374|  10.7k|        FIELD(m_spent_height)
  ------------------
  |  |  226|  10.7k|  do {							\
  |  |  227|  10.7k|    ar.tag(#f);						\
  |  |  228|  10.7k|    bool r = do_serialize(ar, f);			\
  |  |  229|  10.7k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 10.7k]
  |  |  |  Branch (229:15): [True: 16, False: 10.7k]
  |  |  ------------------
  |  |  230|  10.7k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  375|  10.7k|        FIELD(m_key_image)
  ------------------
  |  |  226|  10.7k|  do {							\
  |  |  227|  10.7k|    ar.tag(#f);						\
  |  |  228|  10.7k|    bool r = do_serialize(ar, f);			\
  |  |  229|  10.7k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 10.7k]
  |  |  |  Branch (229:15): [True: 17, False: 10.6k]
  |  |  ------------------
  |  |  230|  10.7k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  376|  10.6k|        FIELD(m_mask)
  ------------------
  |  |  226|  10.6k|  do {							\
  |  |  227|  10.6k|    ar.tag(#f);						\
  |  |  228|  10.6k|    bool r = do_serialize(ar, f);			\
  |  |  229|  10.6k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 10.6k]
  |  |  |  Branch (229:15): [True: 20, False: 10.6k]
  |  |  ------------------
  |  |  230|  10.6k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  377|  10.6k|        FIELD(m_amount)
  ------------------
  |  |  226|  10.6k|  do {							\
  |  |  227|  10.6k|    ar.tag(#f);						\
  |  |  228|  10.6k|    bool r = do_serialize(ar, f);			\
  |  |  229|  10.6k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 10.6k]
  |  |  |  Branch (229:15): [True: 10, False: 10.6k]
  |  |  ------------------
  |  |  230|  10.6k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  378|  10.6k|        FIELD(m_rct)
  ------------------
  |  |  226|  10.6k|  do {							\
  |  |  227|  10.6k|    ar.tag(#f);						\
  |  |  228|  10.6k|    bool r = do_serialize(ar, f);			\
  |  |  229|  10.6k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 10.6k]
  |  |  |  Branch (229:15): [True: 4, False: 10.6k]
  |  |  ------------------
  |  |  230|  10.6k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  379|  10.6k|        FIELD(m_key_image_known)
  ------------------
  |  |  226|  10.6k|  do {							\
  |  |  227|  10.6k|    ar.tag(#f);						\
  |  |  228|  10.6k|    bool r = do_serialize(ar, f);			\
  |  |  229|  10.6k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 10.6k]
  |  |  |  Branch (229:15): [True: 6, False: 10.6k]
  |  |  ------------------
  |  |  230|  10.6k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  380|  10.6k|        FIELD(m_key_image_request)
  ------------------
  |  |  226|  10.6k|  do {							\
  |  |  227|  10.6k|    ar.tag(#f);						\
  |  |  228|  10.6k|    bool r = do_serialize(ar, f);			\
  |  |  229|  10.6k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 10.6k]
  |  |  |  Branch (229:15): [True: 3, False: 10.6k]
  |  |  ------------------
  |  |  230|  10.6k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  381|  10.6k|        FIELD(m_pk_index)
  ------------------
  |  |  226|  10.6k|  do {							\
  |  |  227|  10.6k|    ar.tag(#f);						\
  |  |  228|  10.6k|    bool r = do_serialize(ar, f);			\
  |  |  229|  10.6k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 10.6k]
  |  |  |  Branch (229:15): [True: 4, False: 10.6k]
  |  |  ------------------
  |  |  230|  10.6k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  382|  10.6k|        FIELD(m_subaddr_index)
  ------------------
  |  |  226|  10.6k|  do {							\
  |  |  227|  10.6k|    ar.tag(#f);						\
  |  |  228|  10.6k|    bool r = do_serialize(ar, f);			\
  |  |  229|  10.6k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 25, False: 10.6k]
  |  |  |  Branch (229:15): [True: 0, False: 10.6k]
  |  |  ------------------
  |  |  230|  10.6k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  383|  10.6k|        FIELD(m_key_image_partial)
  ------------------
  |  |  226|  10.6k|  do {							\
  |  |  227|  10.6k|    ar.tag(#f);						\
  |  |  228|  10.6k|    bool r = do_serialize(ar, f);			\
  |  |  229|  10.6k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 10.6k]
  |  |  |  Branch (229:15): [True: 8, False: 10.6k]
  |  |  ------------------
  |  |  230|  10.6k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  384|  10.6k|        FIELD(m_multisig_k)
  ------------------
  |  |  226|  10.6k|  do {							\
  |  |  227|  10.6k|    ar.tag(#f);						\
  |  |  228|  10.6k|    bool r = do_serialize(ar, f);			\
  |  |  229|  10.6k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 157, False: 10.4k]
  |  |  |  Branch (229:15): [True: 0, False: 10.4k]
  |  |  ------------------
  |  |  230|  10.6k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  385|  10.4k|        FIELD(m_multisig_info)
  ------------------
  |  |  226|  10.4k|  do {							\
  |  |  227|  10.4k|    ar.tag(#f);						\
  |  |  228|  10.4k|    bool r = do_serialize(ar, f);			\
  |  |  229|  10.4k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 491, False: 9.95k]
  |  |  |  Branch (229:15): [True: 0, False: 9.95k]
  |  |  ------------------
  |  |  230|  10.4k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  386|  9.95k|        FIELD(m_uses)
  ------------------
  |  |  226|  9.95k|  do {							\
  |  |  227|  9.95k|    ar.tag(#f);						\
  |  |  228|  9.95k|    bool r = do_serialize(ar, f);			\
  |  |  229|  9.95k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 371, False: 9.58k]
  |  |  |  Branch (229:15): [True: 0, False: 9.58k]
  |  |  ------------------
  |  |  230|  9.95k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  387|  9.58k|      END_SERIALIZE()
  ------------------
  |  |  207|  9.58k|  return ar.good();				\
  |  |  208|  9.95k|  }
  ------------------
_ZN5tools7wallet213multisig_info19do_serialize_objectILb0E14binary_archiveEEbRT0_IXT_EE:
  312|  8.84k|      BEGIN_SERIALIZE_OBJECT()
  ------------------
  |  |  184|  8.84k|  bool do_serialize_object(Archive<W> &ar){
  ------------------
  313|  8.84k|        FIELD(m_signer)
  ------------------
  |  |  226|  8.84k|  do {							\
  |  |  227|  8.84k|    ar.tag(#f);						\
  |  |  228|  8.84k|    bool r = do_serialize(ar, f);			\
  |  |  229|  8.84k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 8.84k]
  |  |  |  Branch (229:15): [True: 66, False: 8.77k]
  |  |  ------------------
  |  |  230|  8.84k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  314|  8.77k|        FIELD(m_LR)
  ------------------
  |  |  226|  8.77k|  do {							\
  |  |  227|  8.77k|    ar.tag(#f);						\
  |  |  228|  8.77k|    bool r = do_serialize(ar, f);			\
  |  |  229|  8.77k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 117, False: 8.65k]
  |  |  |  Branch (229:15): [True: 0, False: 8.65k]
  |  |  ------------------
  |  |  230|  8.77k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  315|  8.65k|        FIELD(m_partial_key_images)
  ------------------
  |  |  226|  8.65k|  do {							\
  |  |  227|  8.65k|    ar.tag(#f);						\
  |  |  228|  8.65k|    bool r = do_serialize(ar, f);			\
  |  |  229|  8.65k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 187, False: 8.47k]
  |  |  |  Branch (229:15): [True: 0, False: 8.47k]
  |  |  ------------------
  |  |  230|  8.65k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  316|  8.47k|      END_SERIALIZE()
  ------------------
  |  |  207|  8.47k|  return ar.good();				\
  |  |  208|  8.65k|  }
  ------------------
_ZN5tools7wallet213multisig_info2LR19do_serialize_objectILb0E14binary_archiveEEbRT0_IXT_EE:
  302|  57.8k|        BEGIN_SERIALIZE_OBJECT()
  ------------------
  |  |  184|  57.8k|  bool do_serialize_object(Archive<W> &ar){
  ------------------
  303|  57.8k|          FIELD(m_L)
  ------------------
  |  |  226|  57.8k|  do {							\
  |  |  227|  57.8k|    ar.tag(#f);						\
  |  |  228|  57.8k|    bool r = do_serialize(ar, f);			\
  |  |  229|  57.8k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 57.8k]
  |  |  |  Branch (229:15): [True: 46, False: 57.7k]
  |  |  ------------------
  |  |  230|  57.8k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  304|  57.7k|          FIELD(m_R)
  ------------------
  |  |  226|  57.7k|  do {							\
  |  |  227|  57.7k|    ar.tag(#f);						\
  |  |  228|  57.7k|    bool r = do_serialize(ar, f);			\
  |  |  229|  57.7k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 57.7k]
  |  |  |  Branch (229:15): [True: 30, False: 57.7k]
  |  |  ------------------
  |  |  230|  57.7k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  305|  57.7k|        END_SERIALIZE()
  ------------------
  |  |  207|  57.7k|  return ar.good();				\
  |  |  208|  57.7k|  }
  ------------------
_ZN5tools7wallet225exported_transfer_details19do_serialize_objectILb0E14binary_archiveEEbRT0_IXT_EE:
  414|  44.1k|      BEGIN_SERIALIZE_OBJECT()
  ------------------
  |  |  184|  44.1k|  bool do_serialize_object(Archive<W> &ar){
  ------------------
  415|  44.1k|        VERSION_FIELD(1)
  ------------------
  |  |  289|  44.1k|  uint32_t version = v;				\
  |  |  290|  44.1k|  do {						\
  |  |  291|  44.1k|    ar.tag("version");				\
  |  |  292|  44.1k|    ar.serialize_varint(version);		\
  |  |  293|  44.1k|    if (!ar.good()) return false;		\
  |  |  ------------------
  |  |  |  Branch (293:9): [True: 29, False: 44.1k]
  |  |  ------------------
  |  |  294|  44.1k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (294:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  416|  44.1k|        if (version < 1)
  ------------------
  |  Branch (416:13): [True: 215, False: 43.8k]
  ------------------
  417|    215|          return false;
  418|  43.8k|        FIELD(m_pubkey)
  ------------------
  |  |  226|  43.8k|  do {							\
  |  |  227|  43.8k|    ar.tag(#f);						\
  |  |  228|  43.8k|    bool r = do_serialize(ar, f);			\
  |  |  229|  43.8k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 43.8k]
  |  |  |  Branch (229:15): [True: 141, False: 43.7k]
  |  |  ------------------
  |  |  230|  43.8k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  419|  43.7k|        VARINT_FIELD(m_internal_output_index)
  ------------------
  |  |  252|  43.7k|  do {						\
  |  |  253|  43.7k|    ar.tag(#f);					\
  |  |  254|  43.7k|    ar.serialize_varint(f);			\
  |  |  255|  43.7k|    if (!ar.good()) return false;		\
  |  |  ------------------
  |  |  |  Branch (255:9): [True: 16, False: 43.7k]
  |  |  ------------------
  |  |  256|  43.7k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (256:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  420|  43.7k|        VARINT_FIELD(m_global_output_index)
  ------------------
  |  |  252|  43.7k|  do {						\
  |  |  253|  43.7k|    ar.tag(#f);					\
  |  |  254|  43.7k|    ar.serialize_varint(f);			\
  |  |  255|  43.7k|    if (!ar.good()) return false;		\
  |  |  ------------------
  |  |  |  Branch (255:9): [True: 16, False: 43.7k]
  |  |  ------------------
  |  |  256|  43.7k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (256:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  421|  43.7k|        FIELD(m_tx_pubkey)
  ------------------
  |  |  226|  43.7k|  do {							\
  |  |  227|  43.7k|    ar.tag(#f);						\
  |  |  228|  43.7k|    bool r = do_serialize(ar, f);			\
  |  |  229|  43.7k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 43.7k]
  |  |  |  Branch (229:15): [True: 56, False: 43.6k]
  |  |  ------------------
  |  |  230|  43.7k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  422|  43.6k|        FIELD(m_flags.flags)
  ------------------
  |  |  226|  43.6k|  do {							\
  |  |  227|  43.6k|    ar.tag(#f);						\
  |  |  228|  43.6k|    bool r = do_serialize(ar, f);			\
  |  |  229|  43.6k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 43.6k]
  |  |  |  Branch (229:15): [True: 5, False: 43.6k]
  |  |  ------------------
  |  |  230|  43.6k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  423|  43.6k|        VARINT_FIELD(m_amount)
  ------------------
  |  |  252|  43.6k|  do {						\
  |  |  253|  43.6k|    ar.tag(#f);					\
  |  |  254|  43.6k|    ar.serialize_varint(f);			\
  |  |  255|  43.6k|    if (!ar.good()) return false;		\
  |  |  ------------------
  |  |  |  Branch (255:9): [True: 12, False: 43.6k]
  |  |  ------------------
  |  |  256|  43.6k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (256:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  424|  43.6k|        FIELD(m_additional_tx_keys)
  ------------------
  |  |  226|  43.6k|  do {							\
  |  |  227|  43.6k|    ar.tag(#f);						\
  |  |  228|  43.6k|    bool r = do_serialize(ar, f);			\
  |  |  229|  43.6k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 32, False: 43.6k]
  |  |  |  Branch (229:15): [True: 0, False: 43.6k]
  |  |  ------------------
  |  |  230|  43.6k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  425|  43.6k|        VARINT_FIELD(m_subaddr_index_major)
  ------------------
  |  |  252|  43.6k|  do {						\
  |  |  253|  43.6k|    ar.tag(#f);					\
  |  |  254|  43.6k|    ar.serialize_varint(f);			\
  |  |  255|  43.6k|    if (!ar.good()) return false;		\
  |  |  ------------------
  |  |  |  Branch (255:9): [True: 9, False: 43.6k]
  |  |  ------------------
  |  |  256|  43.6k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (256:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  426|  43.6k|        VARINT_FIELD(m_subaddr_index_minor)
  ------------------
  |  |  252|  43.6k|  do {						\
  |  |  253|  43.6k|    ar.tag(#f);					\
  |  |  254|  43.6k|    ar.serialize_varint(f);			\
  |  |  255|  43.6k|    if (!ar.good()) return false;		\
  |  |  ------------------
  |  |  |  Branch (255:9): [True: 1, False: 43.6k]
  |  |  ------------------
  |  |  256|  43.6k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (256:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  427|  43.6k|      END_SERIALIZE()
  ------------------
  |  |  207|  43.6k|  return ar.good();				\
  |  |  208|  43.6k|  }
  ------------------
_ZN5tools9hashchainC2Ev:
  179|      1|    hashchain(): m_genesis(crypto::null_hash), m_offset(0) {}
_ZN5tools9hashchain9push_backERKN6crypto4hashE:
  184|      1|    void push_back(const crypto::hash &hash) { if (m_offset == 0 && m_blockchain.empty()) m_genesis = hash; m_blockchain.push_back(hash); }
  ------------------
  |  Branch (184:52): [True: 1, False: 0]
  |  Branch (184:69): [True: 1, False: 0]
  ------------------
_ZN5tools9hashchain5clearEv:
  189|      1|    void clear() { m_offset = 0; m_blockchain.clear(); }
_ZN5tools7wallet214tx_scan_info_tC2Ev:
  329|  23.7k|      tx_scan_info_t(): amount(0), money_transfered(0), error(true) {}
_ZNK5tools7wallet216transfer_details14get_public_keyEv:
  357|    262|      const crypto::public_key get_public_key() const {
  358|    262|        crypto::public_key output_public_key;
  359|    262|        THROW_WALLET_EXCEPTION_IF(m_tx.vout.size() <= m_internal_output_index,
  ------------------
  |  | 1040|    262|  if (cond)                                                                                                 \
  |  |  ------------------
  |  |  |  Branch (1040:7): [True: 18, False: 244]
  |  |  ------------------
  |  | 1041|    262|  {                                                                                                         \
  |  | 1042|     18|    LOG_ERROR(#cond << ". THROW EXCEPTION: " << #err_type);                                                 \
  |  |  ------------------
  |  |  |  |  100|     18|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|     18|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|     18|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|     18|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|     18|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|     18|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 18]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|     18|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1043|     18|    tools::error::throw_wallet_ex<err_type>(std::string(__FILE__ ":" STRINGIZE(__LINE__)), ## __VA_ARGS__); \
  |  |  ------------------
  |  |  |  | 1031|     18|#define STRINGIZE(x) STRINGIZE_DETAIL(x)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1030|     18|#define STRINGIZE_DETAIL(x) #x
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1044|     18|  }
  ------------------
  360|    262|          error::wallet_internal_error, "Too few outputs, outputs may be corrupted");
  361|    262|        THROW_WALLET_EXCEPTION_IF(!get_output_public_key(m_tx.vout[m_internal_output_index], output_public_key),
  ------------------
  |  | 1040|    262|  if (cond)                                                                                                 \
  |  |  ------------------
  |  |  |  Branch (1040:7): [True: 27, False: 235]
  |  |  ------------------
  |  | 1041|    262|  {                                                                                                         \
  |  | 1042|     27|    LOG_ERROR(#cond << ". THROW EXCEPTION: " << #err_type);                                                 \
  |  |  ------------------
  |  |  |  |  100|     27|#define LOG_ERROR(x) MERROR(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|     27|#define MERROR(x) MCERROR(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   53|     27|#define MCERROR(cat,x) MCLOG(el::Level::Error,cat, el::Color::Default, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   49|     27|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   43|     27|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |  |  |   44|     27|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 27]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |  |  |   47|     27|  } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1043|     27|    tools::error::throw_wallet_ex<err_type>(std::string(__FILE__ ":" STRINGIZE(__LINE__)), ## __VA_ARGS__); \
  |  |  ------------------
  |  |  |  | 1031|     27|#define STRINGIZE(x) STRINGIZE_DETAIL(x)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1030|     27|#define STRINGIZE_DETAIL(x) #x
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1044|     27|  }
  ------------------
  362|    262|          error::wallet_internal_error, "Unable to get output public key from output");
  363|    262|        return output_public_key;
  364|    262|      };
_ZN5tools7wallet211get_accountEv:
 1061|  5.59k|    cryptonote::account_base& get_account(){return m_account;}
_ZNK5tools7wallet211get_accountEv:
 1062|  5.59k|    const cryptonote::account_base& get_account()const{return m_account;}
_ZNK5tools7wallet227get_num_subaddress_accountsEv:
 1124|      3|    size_t get_num_subaddress_accounts() const { return m_subaddress_labels.size(); }
_ZNK5tools7wallet216get_daemon_loginEv:
 1547|      1|    const boost::optional<epee::net_utils::http::login>& get_daemon_login() const { return m_daemon_login; }
_ZN5tools7wallet213signed_tx_set19do_serialize_objectILb1E14binary_archiveEEbRT0_IXT_EE:
  719|  5.59k|      BEGIN_SERIALIZE_OBJECT()
  ------------------
  |  |  184|  5.59k|  bool do_serialize_object(Archive<W> &ar){
  ------------------
  720|  5.59k|        VERSION_FIELD(0)
  ------------------
  |  |  289|  5.59k|  uint32_t version = v;				\
  |  |  290|  5.59k|  do {						\
  |  |  291|  5.59k|    ar.tag("version");				\
  |  |  292|  5.59k|    ar.serialize_varint(version);		\
  |  |  293|  5.59k|    if (!ar.good()) return false;		\
  |  |  ------------------
  |  |  |  Branch (293:9): [True: 0, False: 5.59k]
  |  |  ------------------
  |  |  294|  5.59k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (294:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  721|  5.59k|        FIELD(ptx)
  ------------------
  |  |  226|  5.59k|  do {							\
  |  |  227|  5.59k|    ar.tag(#f);						\
  |  |  228|  5.59k|    bool r = do_serialize(ar, f);			\
  |  |  229|  5.59k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 5.59k]
  |  |  |  Branch (229:15): [True: 0, False: 5.59k]
  |  |  ------------------
  |  |  230|  5.59k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  722|  5.59k|        FIELD(key_images)
  ------------------
  |  |  226|  5.59k|  do {							\
  |  |  227|  5.59k|    ar.tag(#f);						\
  |  |  228|  5.59k|    bool r = do_serialize(ar, f);			\
  |  |  229|  5.59k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 5.59k]
  |  |  |  Branch (229:15): [True: 0, False: 5.59k]
  |  |  ------------------
  |  |  230|  5.59k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  723|  5.59k|        FIELD(tx_key_images)
  ------------------
  |  |  226|  5.59k|  do {							\
  |  |  227|  5.59k|    ar.tag(#f);						\
  |  |  228|  5.59k|    bool r = do_serialize(ar, f);			\
  |  |  229|  5.59k|    if (!r || !ar.good()) return false;			\
  |  |  ------------------
  |  |  |  Branch (229:9): [True: 0, False: 5.59k]
  |  |  |  Branch (229:15): [True: 0, False: 5.59k]
  |  |  ------------------
  |  |  230|  5.59k|  } while(0);
  |  |  ------------------
  |  |  |  Branch (230:11): [Folded - Ignored]
  |  |  ------------------
  ------------------
  724|  5.59k|      END_SERIALIZE()
  ------------------
  |  |  207|  5.59k|  return ar.good();				\
  |  |  208|  5.59k|  }
  ------------------

_ZN5tools5error21wallet_internal_errorC2EONSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKS8_:
  175|  2.65k|        : wallet_runtime_error(std::move(loc), message)
  176|  2.65k|      {
  177|  2.65k|      }
_ZN5tools5error14transfer_errorC2EONSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKS8_:
  484|  1.49k|        : wallet_logic_error(std::move(loc), message)
  485|  1.49k|      {
  486|  1.49k|      }
_ZN5tools5error18tx_not_constructedC2EONSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS2_6vectorIN10cryptonote15tx_source_entryENS6_ISC_EEEERKNSA_INSB_20tx_destination_entryENS6_ISH_EEEENSB_12network_typeE:
  614|  1.35k|        : transfer_error(std::move(loc), "transaction was not constructed")
  615|  1.35k|        , m_sources(sources)
  616|  1.35k|        , m_destinations(destinations)
  617|  1.35k|        , m_nettype(nettype)
  618|  1.35k|      {
  619|  1.35k|      }
_ZN5tools5error19nonzero_unlock_timeC2EONSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  806|    133|        : transfer_error(std::move(loc), "transaction cannot have non-zero unlock time")
  807|    133|      {
  808|    133|      }
_ZN5tools5error15throw_wallet_exINS0_21wallet_internal_errorEJA42_cEEEvONSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEDpRKT0_:
  997|     18|    {
  998|     18|      TException e(std::move(loc), args...);
  999|     18|      LOG_PRINT_L0(e.to_string());
  ------------------
  |  |  101|     18|#define LOG_PRINT_L0(x) MWARNING(x)
  |  |  ------------------
  |  |  |  |   76|     18|#define MWARNING(x) MCWARNING(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   54|     18|#define MCWARNING(cat,x) MCLOG(el::Level::Warning,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|     18|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|     18|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|     18|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 18]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|     18|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1000|     18|      throw e;
 1001|     18|    }
_ZN5tools5error15throw_wallet_exINS0_21wallet_internal_errorEJA44_cEEEvONSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEDpRKT0_:
  997|     27|    {
  998|     27|      TException e(std::move(loc), args...);
  999|     27|      LOG_PRINT_L0(e.to_string());
  ------------------
  |  |  101|     27|#define LOG_PRINT_L0(x) MWARNING(x)
  |  |  ------------------
  |  |  |  |   76|     27|#define MWARNING(x) MCWARNING(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   54|     27|#define MCWARNING(cat,x) MCLOG(el::Level::Warning,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|     27|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|     27|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|     27|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 27]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|     27|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1000|     27|      throw e;
 1001|     27|    }
_ZN5tools5error17wallet_error_baseISt11logic_errorEC2EONSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERKSA_:
  124|  1.49k|        : Base(message)
  125|  1.49k|        , m_loc(loc)
  126|  1.49k|      {
  127|  1.49k|      }
_ZN5tools5error17wallet_error_baseISt13runtime_errorEC2EONSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERKSA_:
  124|  2.65k|        : Base(message)
  125|  2.65k|        , m_loc(loc)
  126|  2.65k|      {
  127|  2.65k|      }
_ZN5tools5error15throw_wallet_exINS0_21wallet_internal_errorEJNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEvOS9_DpRKT0_:
  997|    116|    {
  998|    116|      TException e(std::move(loc), args...);
  999|    116|      LOG_PRINT_L0(e.to_string());
  ------------------
  |  |  101|    116|#define LOG_PRINT_L0(x) MWARNING(x)
  |  |  ------------------
  |  |  |  |   76|    116|#define MWARNING(x) MCWARNING(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   54|    116|#define MCWARNING(cat,x) MCLOG(el::Level::Warning,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|    116|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|    116|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|    116|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 116]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|    116|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1000|    116|      throw e;
 1001|    116|    }
_ZN5tools5error15throw_wallet_exINS0_21wallet_internal_errorEJA29_cEEEvONSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEDpRKT0_:
  997|  1.03k|    {
  998|  1.03k|      TException e(std::move(loc), args...);
  999|  1.03k|      LOG_PRINT_L0(e.to_string());
  ------------------
  |  |  101|  1.03k|#define LOG_PRINT_L0(x) MWARNING(x)
  |  |  ------------------
  |  |  |  |   76|  1.03k|#define MWARNING(x) MCWARNING(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   54|  1.03k|#define MCWARNING(cat,x) MCLOG(el::Level::Warning,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|  1.03k|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|  1.03k|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|  1.03k|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 1.03k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|  1.03k|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1000|  1.03k|      throw e;
 1001|  1.03k|    }
_ZN5tools5error15throw_wallet_exINS0_21wallet_internal_errorEJA34_cEEEvONSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEDpRKT0_:
  997|     55|    {
  998|     55|      TException e(std::move(loc), args...);
  999|     55|      LOG_PRINT_L0(e.to_string());
  ------------------
  |  |  101|     55|#define LOG_PRINT_L0(x) MWARNING(x)
  |  |  ------------------
  |  |  |  |   76|     55|#define MWARNING(x) MCWARNING(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   54|     55|#define MCWARNING(cat,x) MCLOG(el::Level::Warning,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|     55|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|     55|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|     55|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 55]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|     55|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1000|     55|      throw e;
 1001|     55|    }
_ZN5tools5error15throw_wallet_exINS0_21wallet_internal_errorEJA14_cEEEvONSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEDpRKT0_:
  997|    567|    {
  998|    567|      TException e(std::move(loc), args...);
  999|    567|      LOG_PRINT_L0(e.to_string());
  ------------------
  |  |  101|    567|#define LOG_PRINT_L0(x) MWARNING(x)
  |  |  ------------------
  |  |  |  |   76|    567|#define MWARNING(x) MCWARNING(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   54|    567|#define MCWARNING(cat,x) MCLOG(el::Level::Warning,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|    567|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|    567|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|    567|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 567]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|    567|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1000|    567|      throw e;
 1001|    567|    }
_ZN5tools5error15throw_wallet_exINS0_21wallet_internal_errorEJA31_cEEEvONSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEDpRKT0_:
  997|    259|    {
  998|    259|      TException e(std::move(loc), args...);
  999|    259|      LOG_PRINT_L0(e.to_string());
  ------------------
  |  |  101|    259|#define LOG_PRINT_L0(x) MWARNING(x)
  |  |  ------------------
  |  |  |  |   76|    259|#define MWARNING(x) MCWARNING(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   54|    259|#define MCWARNING(cat,x) MCLOG(el::Level::Warning,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|    259|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|    259|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|    259|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 259]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|    259|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1000|    259|      throw e;
 1001|    259|    }
_ZN5tools5error15throw_wallet_exINS0_19nonzero_unlock_timeEJEEEvONSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEDpRKT0_:
  997|    133|    {
  998|    133|      TException e(std::move(loc), args...);
  999|    133|      LOG_PRINT_L0(e.to_string());
  ------------------
  |  |  101|    133|#define LOG_PRINT_L0(x) MWARNING(x)
  |  |  ------------------
  |  |  |  |   76|    133|#define MWARNING(x) MCWARNING(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   54|    133|#define MCWARNING(cat,x) MCLOG(el::Level::Warning,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|    133|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|    133|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|    133|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 133]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|    133|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1000|    133|      throw e;
 1001|    133|    }
_ZN5tools5error15throw_wallet_exINS0_18tx_not_constructedEJNSt3__16vectorIN10cryptonote15tx_source_entryENS3_9allocatorIS6_EEEENS4_INS5_20tx_destination_entryENS7_ISA_EEEENS5_12network_typeEEEEvONS3_12basic_stringIcNS3_11char_traitsIcEENS7_IcEEEEDpRKT0_:
  997|  1.35k|    {
  998|  1.35k|      TException e(std::move(loc), args...);
  999|  1.35k|      LOG_PRINT_L0(e.to_string());
  ------------------
  |  |  101|  1.35k|#define LOG_PRINT_L0(x) MWARNING(x)
  |  |  ------------------
  |  |  |  |   76|  1.35k|#define MWARNING(x) MCWARNING(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   54|  1.35k|#define MCWARNING(cat,x) MCLOG(el::Level::Warning,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|  1.35k|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|  1.35k|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|  1.35k|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 1.35k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|  1.35k|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1000|  1.35k|      throw e;
 1001|  1.35k|    }
_ZN5tools5error15throw_wallet_exINS0_21wallet_internal_errorEJA36_cEEEvONSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEDpRKT0_:
  997|     12|    {
  998|     12|      TException e(std::move(loc), args...);
  999|     12|      LOG_PRINT_L0(e.to_string());
  ------------------
  |  |  101|     12|#define LOG_PRINT_L0(x) MWARNING(x)
  |  |  ------------------
  |  |  |  |   76|     12|#define MWARNING(x) MCWARNING(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   54|     12|#define MCWARNING(cat,x) MCLOG(el::Level::Warning,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|     12|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|     12|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|     12|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 12]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|     12|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1000|     12|      throw e;
 1001|     12|    }
_ZN5tools5error15throw_wallet_exINS0_21wallet_internal_errorEJA57_cEEEvONSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEDpRKT0_:
  997|    161|    {
  998|    161|      TException e(std::move(loc), args...);
  999|    161|      LOG_PRINT_L0(e.to_string());
  ------------------
  |  |  101|    161|#define LOG_PRINT_L0(x) MWARNING(x)
  |  |  ------------------
  |  |  |  |   76|    161|#define MWARNING(x) MCWARNING(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   54|    161|#define MCWARNING(cat,x) MCLOG(el::Level::Warning,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|    161|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|    161|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|    161|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 161]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|    161|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1000|    161|      throw e;
 1001|    161|    }
_ZN5tools5error15throw_wallet_exINS0_21wallet_internal_errorEJA51_cEEEvONSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEDpRKT0_:
  997|    130|    {
  998|    130|      TException e(std::move(loc), args...);
  999|    130|      LOG_PRINT_L0(e.to_string());
  ------------------
  |  |  101|    130|#define LOG_PRINT_L0(x) MWARNING(x)
  |  |  ------------------
  |  |  |  |   76|    130|#define MWARNING(x) MCWARNING(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   54|    130|#define MCWARNING(cat,x) MCLOG(el::Level::Warning,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|    130|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|    130|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|    130|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 130]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|    130|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1000|    130|      throw e;
 1001|    130|    }
_ZN5tools5error15throw_wallet_exINS0_21wallet_internal_errorEJA49_cEEEvONSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEDpRKT0_:
  997|    180|    {
  998|    180|      TException e(std::move(loc), args...);
  999|    180|      LOG_PRINT_L0(e.to_string());
  ------------------
  |  |  101|    180|#define LOG_PRINT_L0(x) MWARNING(x)
  |  |  ------------------
  |  |  |  |   76|    180|#define MWARNING(x) MCWARNING(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   54|    180|#define MCWARNING(cat,x) MCLOG(el::Level::Warning,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|    180|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|    180|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|    180|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 180]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|    180|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1000|    180|      throw e;
 1001|    180|    }
_ZN5tools5error15throw_wallet_exINS0_21wallet_internal_errorEJA82_cEEEvONSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEDpRKT0_:
  997|     93|    {
  998|     93|      TException e(std::move(loc), args...);
  999|     93|      LOG_PRINT_L0(e.to_string());
  ------------------
  |  |  101|     93|#define LOG_PRINT_L0(x) MWARNING(x)
  |  |  ------------------
  |  |  |  |   76|     93|#define MWARNING(x) MCWARNING(MONERO_DEFAULT_LOG_CATEGORY,x)
  |  |  |  |  ------------------
  |  |  |  |  |  |   54|     93|#define MCWARNING(cat,x) MCLOG(el::Level::Warning,cat, el::Color::Default, x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   49|     93|#define MCLOG(level, cat, color, x) MCLOG_TYPE(level, cat, color, el::base::DispatchAction::NormalLog, x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   43|     93|#define MCLOG_TYPE(level, cat, color, type, x) do { \
  |  |  |  |  |  |  |  |  |  |   44|     93|    if (el::Loggers::allowed(level, cat)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (44:9): [True: 0, False: 93]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   45|      0|      el::base::Writer(level, color, __FILE__, __LINE__, ELPP_FUNC, type).construct(cat) << x; \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  303|      0|#  define ELPP_FUNC __PRETTY_FUNCTION__
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   46|      0|    } \
  |  |  |  |  |  |  |  |  |  |   47|     93|  } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (47:12): [Folded - Ignored]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1000|     93|      throw e;
 1001|     93|    }

LLVMFuzzerTestOneInput:
   52|  19.4k|BEGIN_SIMPLE_FUZZER()
  ------------------
  |  |   53|  9.74k|  { \
  |  |   54|  9.74k|    try \
  |  |   55|  9.74k|    { \
  |  |   56|  9.74k|      static bool first = true; \
  |  |   57|  9.74k|      if (first) \
  |  |  ------------------
  |  |  |  Branch (57:11): [True: 1, False: 9.74k]
  |  |  ------------------
  |  |   58|  9.74k|      { \
  |  |   59|      1|        if (init()) \
  |  |  ------------------
  |  |  |  Branch (59:13): [True: 0, False: 1]
  |  |  ------------------
  |  |   60|      1|          return 1; \
  |  |   61|      1|        first = false; \
  |  |   62|      1|      } \
  ------------------
   53|  9.74k|  tools::wallet2::unsigned_tx_set exported_txs;
   54|  9.74k|  binary_archive<false> ar{{buf, len}};
   55|  9.74k|  ::serialization::serialize(ar, exported_txs);
   56|  9.74k|  std::vector<tools::wallet2::pending_tx> ptx;
   57|  9.74k|  bool success = wallet->sign_tx(exported_txs, "/tmp/cold-transaction-test-signed", ptx);
   58|  9.74k|  std::cout << (success ? "signed" : "error") << std::endl;
  ------------------
  |  Branch (58:17): [True: 5.59k, False: 4.14k]
  ------------------
   59|  9.74k|END_SIMPLE_FUZZER()
  ------------------
  |  |   65|  9.74k|    } \
  |  |   66|  9.74k|    catch (const std::exception &e) \
  |  |   67|  9.74k|    { \
  |  |   68|  4.14k|      fprintf(stderr, "Exception: %s\n", e.what()); \
  |  |   69|  4.14k|      delete el::base::elStorage; \
  |  |   70|  4.14k|      el::base::elStorage = NULL; \
  |  |   71|  4.14k|      return 0; \
  |  |   72|  4.14k|    } \
  |  |   73|  9.74k|    delete el::base::elStorage; \
  |  |   74|  5.59k|    el::base::elStorage = NULL; \
  |  |   75|  5.59k|    return 0; \
  |  |   76|  9.74k|  } \
  ------------------
cold-transaction.cpp:_ZL4initv:
   39|      2|BEGIN_INIT_SIMPLE_FUZZER()
  ------------------
  |  |   36|      1|  { \
  |  |   37|      1|    try \
  |  |   38|      1|    {
  ------------------
   40|      2|  static tools::wallet2 local_wallet;
   41|      2|  wallet = &local_wallet;
   42|       |
   43|      2|  static const char * const spendkey_hex = "f285d4ac9e66271256fc7cde0d3d6b36f66efff6ccd766706c408e86f4997a0d";
   44|      2|  crypto::secret_key spendkey;
   45|      2|  epee::string_tools::hex_to_pod(spendkey_hex, spendkey);
   46|       |
   47|      2|  wallet->init("", boost::none, "", 0, true, epee::net_utils::ssl_support_t::e_ssl_support_disabled);
   48|      2|  wallet->set_subaddress_lookahead(1, 1);
   49|      2|  wallet->generate("", "", spendkey, true, false);
   50|      2|END_INIT_SIMPLE_FUZZER()
  ------------------
  |  |   41|      1|    } \
  |  |   42|      1|    catch (const std::exception &e) \
  |  |   43|      1|    { \
  |  |   44|      0|      fprintf(stderr, "Exception: %s\n", e.what()); \
  |  |   45|      0|      return 1; \
  |  |   46|      0|    } \
  |  |   47|      1|    return 0; \
  |  |   48|      1|  }
  ------------------