std::vector<int> ints{ };
std::vector<bool> booleans{  };
   // ----------------------------
std::cout << "Before the add \n";
std::cout << "Size of ints " << ints.capacity() << "\n";
std::cout << "Size of booleans " << booleans.capacity() << "\n";

ints.push_back(1);
booleans.push_back(true);

   // ----------------------------

std::cout << "\nAfter push_back, Before the reserve \n";

std::cout << "Size of ints " << ints.capacity() << "\n";
std::cout << "Size of booleans " << booleans.capacity() << "\n";

   // ----------------------------

ints.reserve(50);
booleans.reserve(50);

std::cout << "\nAfter the reserve \n";

std::cout << "Size of ints " << ints.capacity() << "\n";
std::cout << "Size of booleans " << booleans.capacity() << "\n";

bool booleans[64];  // 64 bytes

long long booleans = 0;

long long booleans = 0;
auto thirdBit = 1 << 2;
booleans |= thirdBit;

if(booleans & thirdBit == thirdBit)
{
	std::cout << "Third bit is turned on \n";
}

template<class TEntity>
int Calculate(TEntity one, TEntity two)
{
	std::cout << "One\n";  
	return one + two;
}

template<>
int Calculate(std::string one, std::string two)
{
	std::cout << "Two\n";
	return one.size() + two.size();
}

auto a = Calculate(1,2);
auto b = Calculate("One"s,"Two"s);

// Optimize vector<bool> lexicographical comparisons.

// There are several endianness/ordering issues to consider here.
// * Machine endianness is irrelevant. (That affects how an unsigned int is stored
//   as a sequence of bytes. While all of our supported architectures are little-endian,
//   that's irrelevant as long as we avoid reinterpreting unsigned int as a sequence of bytes.)
// * Appending bits to vector<bool> eventually appends words to its underlying storage.
//   For example, vb[10] is stored within vb._Myvec[0], while vb[100] is stored within vb._Myvec[3].
//   This allows us to translate lexicographical comparisons from theoretical bits to physical words.
// * Unsigned integers are written and compared as big-endian (most significant bit first).
//   For example, 0x10u > 0x07u.
// * However, vector<bool> packs bits into words as little-endian (least significant bit first).
//   For example, vector<bool>{false, true, true, true} stores 0b0000'0000'0000'0000'0000'0000'0000'1110u.
// We could bit-reverse words before comparing, but we just need to find the least significant bit that differs.