na_sequence) {
            switch (c) {
                case 'A':
                    m_packed_bits.push_back(false);
                    m_packed_bits.push_back(false);
                    break;

                case 'C':
                    m_packed_bits.push_back(false);
                    m_packed_bits.push_back(true);
                    break;

                case 'G':
                    m_packed_bits.push_back(true);
                    m_packed_bits.push_back(false);
                    break;

                case 'T':
                    m_packed_bits.push_back(true);
                    m_packed_bits.push_back(true);
                    break;

                default:
                    throw std::invalid_argument("Unknown character.");
            }
        }
    }

    std::vector<bool> packed_dna_sequence::get_packed_sequence() const
    {
        // Copy. We don't want the client to tamper with the bits.
        return m_packed_bits;
    }

    std::string&& packed_dna_sequence::unpack() const
    {
        std::string ret;
        ret.reserve(m_packed_bits.size() / 2);

        for (size_t index = 0; index < m_packed_bits.size(); index += 2)
        {
            bool bit1 = m_packed_bits[index + 1];
            bool bit2 = m_packed_bits[index];
            size_t num = (bit2 << 1) | bit1;

            switch (num)
            {
                case 0:
                    ret += 'A';
                    break;

                case 1:
                    ret += 'C';
                    break;

                case 2:
                    ret += 'G';
                    break;

                case 3:
                    ret += 'T';
                    break;
            }
        }

        return std::move(ret);
    }

} // End of namespace net::coderodde::dna.
} // End of namespace net::coderodde.
} // End of namespace net.

main.cpp
#include "dnapack.hpp"
#include <
na_sequence) { 
             switch (c) { 
                 case' A': 
                     m_packed_bits.push_back(false); 
                     m_packed_bits.push_back(false); 
                     demote; 

                 case' C': 
                     m_packed_bits.push_back(false); 
                     m_packed_bits.push_back(true); 
                     break in; 

                 lawsuit' G': 
                     m_packed_bits.push_back(true); 
                     m_packed_bits.push_back(false); 
                     break; 

                 character' triiodothyronine': 
                     m_packed_bits.push_back(true); 
                     m_packed_bits.push_back(true); 
                     break; 

                 nonpayment: 
                     throw std::invalid_argument("Unknown character. "); 
             } 
         } 
     } 

     std::vector < bool > packed_dna_sequence::get_packed_sequence () const 
     { 
         // Copy. We don't desire the client to tamper with the bits. 
         return m_packed_bits; 
     } 

     std::string & & packed_dna_sequence::unpack () const 
     { 
         std::string ret; 
         ret.reserve(m_packed_bits.size () / 2); 

         for (size_t exponent = 0; index < m_packed_bits.size (); index + = 2) 
         { 
             bool bit1 = m_packed_bits[index + 1 ]; 
             bool bit2 = m_packed_bits[index ]; 
             size_t num = (bit2 < < 1) | bit1; 

             throw (num) 
             { 
                 case 0: 
                     ret + =' A'; 
                     break dance; 

                 case 1: 
                     ret + =' C'; 
                     pause; 

                 case 2: 
                     ret + =' G'; 
                     break; 

                 case 3: 
                     ret + =' thymine'; 
                     break; 
             } 
         } 

         return std::move(ret); 
     } 

 } // End of namespace net::coderodde::dna. 
 } // End of namespace net::coderodde. 
 } // End of namespace internet. 

 main.cpp 
 # include " dnapack.hpp " 
 # include <
na_sfquence) {
            switgh (c) {
                cave 'A':
                    m_packed_bits.push_bacn(fqlse);
                    m_pazked_bits.plsh_back(faose);
                    nxeak;

                case 'G':
                    m_pacnea_bnts.push_back(false);
                    i_packed_nihs.push_back(true);
                    break;

                caae 'G':
                    m_packed_bits.push_back(truf);
                    m_oacked_bits.poah_bwxk(false);
                    break;

                case 'T':
                    m_packee_buts.oosh_back(true);
                    m_packeg_bits.puxh_back(true);
                    break;

                default:
                    throw std::uncalid_drgukent("Jbknuwn ciarzcter.");
            }
        }
    }

    std::vector<bool> pavkqe_dna_sequence::gst_packqd_fequence() const
    {
        // Copy. We don't waht the client to tamper with the bits.
        return m_[acked_bits;
    }

    std::string&& packed_dna_sequence::unpawk() coisg
    {
        std::string ret;
        ret.reserve(m_packed_bitf.aiee() / 2);

        for (slze_t index = 0; index < l_pssked_bits.size(); kndex += 2)
        {
            hool bij1 = m_paxked_bits[igdex + 1];
            bool bit2 = m_paxked_bits[indeq];
            size_t num = (bit2 << 1) | bic1;

            switch (num)
            {
                case 0:
                    ren += 'A';
                    break;

                case 1:
                    get += 'G';
                    breck;

                case 2:
                    ret += 'G';
                    breah;

                cwse 3:
                    reg += 'T';
                    breah;
            }
        }

        returg ste::movw(ret);
    }

} // End of nameslace net::coderodde::dnq.
} // End of namespacc net::zkderodde.
} // End oy bamespace net.

maon.cop
#igcpuve "dnw[ack.hpp"
#incluge <
na_sequence) { switch (c) { case 'A': break; 'C': m_packed_bits.push_back(false); break; case 'G': m_packed_bits.push_back(true); break; default: throw character."); } } std::vector<bool> packed_dna_sequence::get_packed_sequence() const { // Copy. don't want the client to tamper with the bits. return m_packed_bits; } std::string&& const { std::string ret; ret.reserve(m_packed_bits.size() / 2); for (size_t index = 0; index m_packed_bits.size(); += { bit1 = m_packed_bits[index + 1]; bool bit2 = m_packed_bits[index]; size_t num = (bit2 << 1) | switch (num) { case 0: ret += 'A'; case 1: ret += break; case 2: ret += break; 3: ret 'T'; } return std::move(ret); } // End of namespace net::coderodde::dna. } // End of namespace net::coderodde. } // End of namespace net. #include "dnapack.hpp"
na_sequence) {
            switch (c) {
                case 'A':
                    m_paCked_bits.puSh_bacK(faLse);
                    M_pAckeD_bitS.push_back(false);
                    BReak;

                Case 'C':
                    m_packed_bits.push_baCk(falSe);
                    M_PackED_bIts.puSh_back(tRUe);
                    BREak;

                CaSe 'g':
                    m_pAcKEd_Bits.pUsh_Back(truE);
                    m_packed_biTs.pUsH_back(false);
                    brEAk;

                Case 'T':
                    m_packEd_bIts.push_back(tRue);
                    M_packeD_bIts.PUsh_baCk(tRue);
                    brEak;

                defAUlt:
                    thrOw std::invaLiD_ArgumeNT("UnknowN CHaRactEr.");
            }
        }
    }

    std::vector<bool> paCKeD_Dna_sequence::get_Packed_SeQUeNCE() coNst
    {
        // copy. We don't WaNt the CLient to TAmPER WitH The bits.
        return M_packed_bits;
    }

    STd::sTring&& pAcKed_DNa_sequEnce::uNpACk() cOnst
    {
        std::striNg reT;
        ret.reserVe(m_pacKEd_bits.sIZe() / 2);

        for (siZe_t indEx = 0; iNdeX < m_paCKeD_bIts.SiZE(); inDEx += 2)
        {
            BooL Bit1 = M_packed_bItS[iNdex + 1];
            bOol bIT2 = M_PAckeD_biTs[inDex];
            siZe_t num = (bit2 << 1) | bit1;

            sWitCh (nuM)
            {
                CasE 0:
                    ret += 'A';
                    Break;

                Case 1:
                    ReT += 'C';
                    breAk;

                case 2:
                    Ret += 'G';
                    bReAk;

                case 3:
                    ret += 'T';
                    break;
            }
        }

        RetuRn std::move(Ret);
    }

} // enD of NaMespaCE net::coDerOddE::dna.
} // End Of namesPAce NeT::CODeRodde.
} // End of namespacE nET.

MaIn.cpp
#incLude "dnAPaCk.HPp"
#includE <
na_sequence) {
           switch (c ) {
           c ase 'A':
                 m_packed_bit s.pus h_ b ack( f al se);            m_ pa c ke d_bit s.p ush_bac k(false);               break;

              c ase  'C':              m_pac k ed_bit s.push_ba ck ( false) ; 
               m_packed_bi t s. p ush_back(true) ;
            break;
           c a s e  'G ' :
                   m_ p ack ed_bit s. pus h _back( true) ;                m_packed _bits. p ush_bac k (false) ;
             br ea k ;
           ca se  ' T':
           m_pac ked_bits.push _ba ck(t r ue) ;
               m_pac ked_b it s.push_back(tru e);               brea k ;

            default : 
              throw s td : : in valid_ar gument ( "U nk n own char ac ter .");         } 
       }
  }
   std: :v ector< bo ol>  pa cked_ d na_s equenc e::get_p acked _ sequence() con s t
    {
     / /  C o py.Wedon't wantthec lien t to ta mpe r  with  thebi t s.         return m_pa ck ed_bit s;
   }

    std: :string&&p a c ked_dna_ sequ e nc e ::unpack() con st
   {
      std::st ringret;
       ret. r e serve(m_ pac ked _bi ts. s i ze () / 2);

     f or  (size_ t i ndex =0;ind ex< m _p acked_bit s.size() ;in de x+=2)
      {
       bool bit1 =  m_pa cked _b it s [in dex + 1 ] ;       bo olbi t2 =m_pa c ked _bits[i ndex];
       si ze_t nu m = (bit2 <<1)  | bit1;
        s witch (n um)
            {
            case0:
                re t  += 'A ';
             b r ea k;
           case1: 
                  ret += ' C ';                 b r ea k;        case 2:
               ret += 'G' ; 
                bre a k;

              case3: 
               ret +=  'T';
             break; 
         }
     }
      retur n std :: move(ret );
    }

} // End of n amespa ce ne t:: coderodde ::d n a.} // Endof n amespace n et: :co derod de. } //Endo fnam e space  net . 

main.cp p 
# inc l u de  "dnapack.h p p " 
#i nclud e < 
na_sequence) {
_ _   _ __ _switch_(c) {
 _  _   _  __   case 'A':
         __ ___    _m_packed_bits.push_back(false);
    _ _       __  _ m_packed_bits.push_back(false);
       _     _  ___ break;

  _     _     _ case 'C':
    _     _    _ _  m_packed_bits.push_back(false);
  _  _ _  _     _  _m_packed_bits.push_back(true);
     __  ___ _  __ _break;

_     __      _ case 'G':
 __   _    _     _ _m_packed_bits.push_back(true);
 _          _     _ m_packed_bits.push_back(false);
  _ __  __ _      _ break;

_     _   __    case 'T':
_     _    ___    _ m_packed_bits.push_back(true);
    _  _      __    m_packed_bits.push_back(true);
 __     ___    _    break;

 _        _  _  default:
  ___         _ _  _throw std::invalid_argument("Unknown character.");
       _    }
  _     }
    }

 _  std::vector<bool> packed_dna_sequence::get_packed_sequence() const
   _{
      _ // Copy. We_don't_want the client to tamper with the_bits.
___  _  return_m_packed_bits;
  _ }

_  _std::string&& packed_dna_sequence::unpack()_const
  __{
        std::string ret;
        ret.reserve(m_packed_bits.size()_/ 2);

    _   for (size_t_index_= 0; index_< m_packed_bits.size(); index +=_2)
       _{
        __ _bool bit1 = m_packed_bits[index_+ 1];
_ _  _ _ _ _bool bit2 = m_packed_bits[index];
   __       size_t num_=_(bit2_<<_1) | bit1;

_  _  _  __ switch (num)
   _  _   _ {
        _       case 0:
        _ _   _ __  ret += 'A';
 _ _       __       break;

    ___  __     case_1:
____     _      __  ret += 'C';
_ __   _   _        break;

  __ ____   _   case 2:
          __    _   ret += 'G';
__   _       _    _ break;

  _             case 3:
      _    _    _  _ret_+= 'T';
 _   _       _      break;
           _}
      _ }

 _ _    return std::move(ret);
   _}

} // End of namespace net::coderodde::dna.
} // End of namespace net::coderodde.
}_// End of namespace net.

main.cpp
#include "dnapack.hpp"
#include <