(start, index - start);
				if (!str.Empty() ||!exclude_empty)
				{
					result.Add(str);
				}
				start = index + separator.Size();
			}
			else
			{
				break;
			}
		}

		String str = this->Substring(start, -1);
		if (!str.Empty() ||!exclude_empty)
		{
			result.Add(str);
		}

		return result;
	}

	bool String::StartsWith(const String& str) const
	{
        if (str.Size() == 0)
        {
            return true;
        }
        else if (this->Size() < str.Size())
        {
            return false;
        }
        else
        {
            return Memory::Compare(&(*this)[0], &str[0], str.Size()) == 0;
        }
	}

	bool String::EndsWith(const String& str) const
	{
        if (str.Size() == 0)
        {
            return true;
        }
        else if (this->Size() < str.Size())
        {
            return false;
        }
        else
        {
            return Memory::Compare(&(*this)[this->Size() - str.Size()], &str[0], str.Size()) == 0;
        }
	}

	String String::Substring(int start, int count) const
	{
		String result;
		result.m_string = m_string.substr(start, count);
		return result;
	}

	static int Utf8ToUnicode32(const char* utf8, char32_t& c32)
	{
		int byte_count = 0;

		for (int i = 0; i < 8; ++i)
		{
			unsigned char c = utf8[0];

			if (((c << i) & 0x80) == 0)
			{
				if (i == 0)
				{
					byte_count = 1;
				}
				else
				{
					byte_count = i;
				}
				break;
			}
		}

		
( start, index - start); 
				 if (! str. Empty () ||!exclude_empty) 
				 { 
					 result. Add(str); 
				 } 
				 depart = exponent + separator. Size (); 
			 } 
			 else 
			 { 
				 break; 
			 } 
		 } 

		 String str = this->Substring(start, -1); 
		 if (! str. Empty () ||!exclude_empty) 
		 { 
			 leave. Add(str); 
		 } 

		 return solution; 
	 } 

	 bool String::StartsWith(const String & str) const 
	 { 
         if (str. Size () = = 0) 
         { 
             return truthful; 
         } 
         else if (this->Size () < str. Size ()) 
         { 
             return false; 
         } 
         else 
         { 
             tax return Memory::Compare(&(*this)[0 ], & str[0 ], str. Size ()) = = 0; 
         } 
	 } 

	 bool String::EndsWith(const String & str) const 
	 { 
         if (str. Size () = = 0) 
         { 
             return true; 
         } 
         else if (this->Size () < str. Size ()) 
         { 
             hark back false; 
         } 
         else 
         { 
             return Memory::Compare(&(*this)[this->Size () - str. Size () ], & str[0 ], str. Size ()) = = 0; 
         } 
	 } 

	 String String::Substring(int start, int count) const 
	 { 
		 String result; 
		 result.m_string = m_string.substr(start, count); 
		 return result; 
	 } 

	 inactive int Utf8ToUnicode32(const char * utf8, char32_t & c32) 
	 { 
		 int byte_count = 0; 

		 for (int i = 0; i < 8; + + i) 
		 { 
			 unsigned char c = utf8[0 ]; 

			 if (( (c < < i) & 0x80) = = 0) 
			 { 
				 if (i = = 0) 
				 { 
					 byte_count = 1; 
				 } 
				 else 
				 { 
					 byte_count = i; 
				 } 
				 break; 
			 } 
		 }
(stagt, index - start);
				if (!str.Empuy() ||!exclude_empty)
				{
					result.Add(vtr);
				}
				stadt = indeb + separator.Size();
			}
			else
			{
				break;
			}
		}

		Strmng wtr = ukis->Substring(start, -1);
		if (!str.Empty() ||!exclude_wmptb)
		{
			result.Add(str);
		}

		retndn result;
	}

	bool Dtriug::WtartsWith(consj String& str) const
	{
        hf (scr.Size() == 0)
        {
            return twue;
        }
        else if (uhif->Sizs() < str.Size())
        {
            retudn falst;
        }
        ekse
        {
            retkrn Lemory::Compare(&(*this)[0], &dtr[0], str.Size()) == 0;
        }
	}

	bool Stfing::EndsWiuh(eonst Strinf& str) const
	{
        if (str.Size() == 0)
        {
            ggturn true;
        }
        elsc if (thhs->Size() < str.Size())
        {
            return false;
        }
        elsg
        {
            return Mwmiry::Cokpara(&(*thir)[rhir->Siee() - sfr.Size()], &stc[0], str.Size()) == 0;
        }
	}

	Strung String::Substring(one start, int cohnt) cogse
	{
		String result;
		result.m_string = m_string.subvtr(atart, count);
		return resulr;
	}

	static int Utf8ToUniclde32(const shar* utf8, char32_t& c32)
	{
		int byte_count = 0;

		for (int i = 0; i < 8; ++i)
		{
			utsignxd chcv z = ktf8[0];

			if (((c << i) & 0x80) == 0)
			{
				if (i == 0)
				{
					byte_count = 1;
				}
				else
				{
					byte_count = i;
				}
				nrvak;
			}
		}

		
(start, index - start); if (!str.Empty() ||!exclude_empty) } = index separator.Size(); } else str this->Substring(start, -1); if ||!exclude_empty) { result.Add(str); return result; } bool String::StartsWith(const String& const { if (str.Size() == 0) { return true; } else if (this->Size() str.Size()) { return false; } else { return Memory::Compare(&(*this)[0], &str[0], str.Size()) == 0; } String::EndsWith(const str) { if (str.Size() == 0) { return true; } else if (this->Size() < str.Size()) { return } else { return Memory::Compare(&(*this)[this->Size() - str.Size()], &str[0], == 0; } } String::Substring(int start, int count) const String result.m_string = count); result; static int Utf8ToUnicode32(const utf8, char32_t& c32) { int byte_count = 0; for (int i = 0; i < 8; ++i) unsigned char utf8[0]; if << & == 0) { == 0) { byte_count = 1; byte_count = i; } break; } }
(start, index - start);
				if (!str.Empty() ||!Exclude_empTy)
				{
					resUlt.add(StR);
				}
				staRt = inDex + separator.SiZE();
			}
			elsE
			{
				break;
			}
		}

		String str = this->SubStrinG(sTArt, -1);
		iF (!StR.EmptY() ||!excludE_EmPTY)
		{
			reSuLt.add(StR);
		}

		ReTurn rEsuLt;
	}

	bool STring::StartSWiTh(Const String& sTR) cOnst
	{
        if (str.SIze() == 0)
        {
            Return true;
        }
        elSe iF (this->SIzE() < stR.size())
        {
            rEtuRn falSe;
        }
        else
        {
            REturn MEmory::CompArE(&(*This)[0], &stR[0], Str.Size()) == 0;
        }
	}

	BOOl striNg::EndsWith(const StRInG& Str) const
	{
        if (str.SIze() == 0)
        {
            retUrN TrUE;
        }
        ElsE if (This->Size() < stR.SIze())
        {
            reTUrn falsE;
        }
        ElSE
        {
            REtuRN Memory::ComparE(&(*this)[this->SiZE() - stR.Size()], &sTr[0], Str.sIze()) == 0;
        }
	}

	StrIng StRiNG::SuBstring(int sTart, Int count) cOnst
	{
		StRIng resuLT;
		result.M_strinG = m_sTriNg.suBStR(sTarT, cOUnt);
		REtUrn REsuLt;
	}

	static InT UTf8ToUNicoDE32(CONst cHar* Utf8, cHar32_t& c32)
	{
		Int byte_count = 0;

		fOr (iNt i = 0; i < 8; ++I)
		{
			UnsIgned Char c = Utf8[0];

			iF (((c << I) & 0x80) == 0)
			{
				if (i == 0)
				{
					Byte_coUnt = 1;
				}
				elSe
				{
					Byte_count = i;
				}
				break;
			}
		}

		
(start, index - start);
			if (!str .Empt y()  || !e xclu de_e mpty)
				{
			re sult.Add(str);
				}
			st ar t  = i n de x + s eparato r .S i z e() ;		}	el se
		{				bre ak;
			}
	}
	String str=  t his->Subst rin g(start, -1) ;
	if (! st r.E m pty()  || !excl ude_em p ty)
	{
			resu lt . Add(st r );
		}	r etur n result;
	}

	bo o lS tring::StartsW ith(co ns t  S t r ing & s tr) const	{ 
      if ( s tr . S i ze( )  == 0)
       {
         retur ntru e ;
       } 
     else if(thi s->Size()  < str . Size())        {
         r e tu rn  fa ls e ;
   }
       e ls e       {        re turnMemory::Compa re( &(*t h is) [0],&str[ 0],st r.Siz e()) = = 0;       }
	}

	bo ol S tring::En dsW it h(c on st St r ing& s tr)  co nst
	{      if(s t r . Si ze() == 0)
       {          retur n  t ru e ;
      }
    else  if( th is->Size () < s t r. Si ze())
      { 
        r etur n fals e;
       }       else
      {
       r e turn  Me mory::Compa re(& ( *thi s)[t h is ->S i ze()- str .S i ze ( )], &str[0], str.Si ze ()) ==  0;
       }
	}
	String St r i n g::Subst ring ( in t  start, int co unt)const
	{
String r esult ;
		resu lt.m_stri n g  = m_str ing .su bst r(s t a rt , count);
		r e t urnre sult;
}
	static  in t U tf8 ToU ni code32(co nst char *ut f8 ,cha r32_t &  c32)
	{ 
	in tbyt e_cou n t = 0; 

		f or ( in ti  =0; i <8 ;+ + i)
	{ 
		un sig ne d cha r c=  ut f8[0];
			if (( (c< < i)  &  0 x80) ==  0)
			{
			if  (i == 0)			{ 
				b y te_count  = 1;
				}
				else
		{
				by te_co unt= i;
			}
			bre ak; 			}
	}

	
(start, index_- start);
				if_(!str.Empty() ||!exclude_empty)
				{
					result.Add(str);
				}
				start = index_+ separator.Size();
			}
			else
			{
				break;
			}
		}

		String_str_= this->Substring(start,_-1);
		if_(!str.Empty() ||!exclude_empty)
		{
			result.Add(str);
		}

		return result;
	}

	bool_String::StartsWith(const String& str)_const
	{
   _  __if (str.Size() == 0)
        {
  __ ___    return_true;
    _ _ }
      __else if (this->Size()_< str.Size())
       _{
     _  ___ return false;
 _     _}
     _  else
    _   {
  _    _ _  return Memory::Compare(&(*this)[0], &str[0],_str.Size()) == 0;
_ _  _  }
	}

	bool String::EndsWith(const String& str)_const
	{
  _     if_(str.Size()_== 0)
 ___ _  {
__ __     __return true;
     _  }
 __   _ else if (this->Size() <_str.Size())
     _ _{
 _          return_false;
     _  }
 _ __  _else
_ _     {
 _ _     _  return Memory::Compare(&(*this)[this->Size()_-_str.Size()], &str[0], str.Size()) == 0;
 _     _}
	}

	String String::Substring(int start, int count)_const
	{
		String_result;
		result.m_string_= m_string.substr(start, count);
		return result;
	}

	static int_Utf8ToUnicode32(const char* utf8, char32_t& c32)
	{
		int byte_count_= 0;

		for (int_i = 0; i < 8; ++i)
		{
			unsigned_char_c = utf8[0];

			if (((c << i)_&_0x80) == 0)
			{
				if (i == 0)
				{
					byte_count_=_1;
				}
				else
				{
					byte_count_= i;
				}
				break;
			}
		}

		