const exception &e,

bool force)

{ const string s (msg + ": " + e. what ());

if (force)

cerr << s << endl;

else

throw runtime_error (s);

const T* b)

{ if (a)

{ if (a != b)

throwf ("a != b");

}

else

a = b;

const T* y)

{ if (x && y)

return *x < *y;

return false;

const U &u)

{ if (u. empty ())

return false;

for (const auto& x : t)

if (u. find (static_cast <typename U::value_type> (x)) != u. end ())

return true;

return false;

const unordered_set<T> &s2)

{ const unordered_set<T>* s1_ = & s1;

const unordered_set<T>* s2_ = & s2;

if (s1. size () > s2. size ())

swap (s1_, s2_);

unordered_set<T> res; res. rehash (s1_->size ());

for (const T& t : *s1_)

if (contains (*s2_, t))

res. insert (t);

return res;

const U &u)

{ for (const auto& x : u)

if (t. find (static_cast <typename U::value_type> (x)) == t. end ())

return false;

return true;

const unordered_set<T> &s2)

{ unordered_set<T> res; res. rehash (s1. size ());

for (const T& t : s1)

if (! contains (s2, t))

res. insert (t);

return res;

const U &u)

{ for (const auto& x : u)

t. erase (x);

{ for (size_t i = 0; i < N; i++)

if (arr [i] == item)

return i;

return no_index;

const KeyParent& key,

Value &value)

// Return: success

// Output: value, if Return

{ const auto& it = m. find (key);

if (it == m. end ())

return false;

value = it->second;

return true;

const KeyParent& key,

Value &value)

// Return: success

// Output: value, if Return

{ const auto& it = m. find (key);

if (it == m. end ())

return false;

value = it->second;

return true;

const KeyParent& key,

Value &value)

// Return: success

// Output: value, if Return

{ const auto& it = m. find (key);

if (it == m. end ())

return false;

value = it->second;

return true;

const From &from)

{

#pragma GCC diagnostic ignored "-Waggressive-loop-optimizations"

to. insert (to. begin (), from. begin (), from. end ());

#pragma GCC diagnostic warning "-Waggressive-loop-optimizations"

From &&from)

{ for (auto&& x : from)

to. insert (std::move (x));

const From &from)

{ for (const auto& x : from)

to. insert (x);

const What &what)

{ for (const auto& x : what)

if (contains (from, x))

from. erase (x);

const T &container,

char sep)

{ bool first = true;

for (const auto& t : container)

{ if (! first)

os << sep;

os << t;

first = false;

}

bool large_hash)

{ return str_hash (s) % (large_hash

? large_hash_class_max

: small_hash_class_max

);

{ switch (b)

{ case efalse: return etrue;

case etrue: return efalse;

default: return b;

}

const string &yes,

const string &no,

const string &ambig)

{ switch (choice)

{ case etrue: return yes;

case efalse: return no;

default: return ambig;

}

{ switch (c)

{ case '-': return false;

case '+': return true;

}

throw runtime_error ("Unknown color character: " + string (1, c));

{ return c != ' '

&& printable (c)

&& ! isLetter (c);

{ if (const char* p = getenv (name. c_str ()))

return p;

return noString;

const string &delimiter,

const string &what)

{ if (! to. empty ())

to += delimiter;

to += what;

{ ostringstream oss;

oss << t;

return oss. str ();

{ static_assert (numeric_limits<T>::max() > 256, "str2 does not work on chars");

T i;

istringstream iss (s);

iss >> i;

if ( Common_sp::strBlank (s)

|| ! iss. eof ()

|| iss. fail ()

)

throw runtime_error ("Cannot convert " + strQuote (s) + " to number");

return i;

T &t)

{ try { t = str2<T> (s); return true; }

catch (...) { return false; }

size_t spaces)

{ size_t i = 0;

while (i < s. size () && i < spaces && s [i] == ' ')

i++;

return i == spaces;

bool upper)

{ if (! upper)

return s;

string s1 (s);

strUpper (s1);

return s1;

bool lower)

{ if (! lower)

return s;

string s1 (s);

strLower (s1);

return s1;

{ if (s. empty ())

return s;

return toUpper (s [0]) + s. substr (1);

size_t size)

{ if (size >= s. size ())

return s;

return s. substr (s. size () - size);

char c)

{ trimTrailing (s, c);

trimLeading (s, c);

{ if (strBlank (s))

return true;

string s1 (s);

trim (s1);

strUpper (s1);

return s1 == "NULL"

|| s1 == "NA"

|| s1 == "N/A"

|| s1 == "MISSING";

const string& key,

bool force)

{ const auto& it = kv. find (key);

if (it == kv. end ())

{ if (force)

return noString;

throw runtime_error ("Key \"" + key + "\" is not found");

}

return it->second;

{ if (const int rem = n % (int) div)

return (uint) (rem > 0 ? rem : (rem + (int) div));

return 0;

uint b)

// Greatest common divisor