--- spal60sr\src\base\StringDivision.original.cpp	Mon Apr 28 00:00:46 2003
+++ spal60sr\src\base\StringDivision.cpp	Mon Apr 28 00:00:46 2003
@@ -1,6 +1,12 @@
 #include <stdio.h>
 #include <float.h>
 #include "StringDivision.h"
+#if defined(OPTIMIZE_STRINGDIVISION) && OPTIMIZE_STRINGDIVISION
+#include "intrinsic.h"
+#endif
+
+#define SPOILERAL_FIX_STRINGDIVISION_POSTFIX_071003_IYA 1
+
 //---------------------------------------------------------------------
 //uRXgN^v
 //---------------------------------------------------------------------
@@ -20,6 +26,7 @@
 	trimSet.insert("\t");
  }
 }
+#if !defined(OPTIMIZE_STRINGDIVISION) || !OPTIMIZE_STRINGDIVISION
 //*********************************************************************
 //uSrcɂPosA2oCg1oCgԂ֐v
 //
@@ -101,6 +108,7 @@
  }
  return false;
 }
+#endif
 //*********************************************************************
 //uSrcɂToken̈ʒuԂ֐v
 //
@@ -118,6 +126,7 @@
 unsigned long TStringDivision::Find(const string &Src, string Token,
 	unsigned long FromIndex, unsigned long ToIndex, unsigned long Option)
 {
+#if !defined(OPTIMIZE_STRINGDIVISION) || !OPTIMIZE_STRINGDIVISION
  if(FromIndex==ToIndex) return string::npos;
  {
 	unsigned long TokenSize = Token.size();
@@ -250,6 +259,200 @@
  }
 
  return string::npos;
+#else
+	size_t                 TokenSize;
+	size_t                 SrcSize;
+	string::const_iterator SrcIt, SrcEnd;
+	size_t                 NestStartTagSize;
+	size_t                 NestEndTagSize;
+	size_t                 EscapeTagSize;
+
+	if (FromIndex == ToIndex)
+		return string::npos;
+
+	TokenSize = Token.size();
+	SrcSize = Src.size();
+
+	// r̕ZȂĘ_O(^^;
+	if (SrcSize < TokenSize)
+		return string::npos;
+
+	// I[Ε␳
+	if (SrcSize < ToIndex || SrcSize < ToIndex + TokenSize)
+		ToIndex = SrcSize - TokenSize + 1;
+
+	SrcIt = Src.begin() + FromIndex;
+	SrcEnd = Src.begin() + ToIndex;
+
+	if (Option & strD::dtNEST)
+	{
+		NestStartTagSize = nestStartTag.size();
+		NestEndTagSize = nestEndTag.size();
+		if (NestStartTagSize == 0 || NestEndTagSize == 0)
+			return string::npos;
+	}
+	if (Option & strD::dtESCAPE)
+	{
+		EscapeTagSize = escapeTag.size();
+		if (EscapeTagSize == 0)
+			return string::npos;
+	}
+
+	// ̃p^[}b`OȂBoyer-Moore@Ď邪A
+	// 2oCglXgAGXP[vV[PXĂ̂1Â(^^;)
+
+	if (Option & strD::dtNEST)
+	{
+		// lXg`FbN
+		if (Option & strD::dtESCAPE)
+		{
+			// GXP[vV[PXgp
+			while (SrcIt < SrcEnd)
+			{
+				if (memcmp(SrcIt, escapeTag.c_str(), EscapeTagSize) != 0)
+				{
+					if (memcmp(SrcIt, nestStartTag.c_str(), NestStartTagSize) == 0)
+					{
+						size_t NCount;
+
+						// lXgJn
+						NCount = 1;
+						SrcIt += NestStartTagSize;
+						while (SrcIt < SrcEnd)
+						{
+							if (memcmp(SrcIt, escapeTag.c_str(), EscapeTagSize) != 0)
+							{
+								if (memcmp(SrcIt, nestStartTag.c_str(), NestStartTagSize) == 0)
+								{
+									// ɃlXg
+									SrcIt += NestStartTagSize;
+									NCount++;
+									continue;
+								}
+								if (memcmp(SrcIt, nestEndTag.c_str(), NestEndTagSize) == 0)
+								{
+									// lXg(i)
+									SrcIt += NestEndTagSize;
+									if (--NCount == 0)
+										break;	// lXgSEo
+									continue;
+								}
+							}
+							else
+							{
+								SrcIt += EscapeTagSize;
+							}
+							if (!__intrinsic_isleadbyte(*SrcIt))
+								SrcIt++;
+							else
+								SrcIt += 2;
+						}
+						continue;	// ɂ܂lXgJn肦ł́B
+					}
+
+					// {r
+					if (memcmp(SrcIt, Token.c_str(), TokenSize) == 0)
+						return SrcIt - Src.begin();
+				}
+				else
+				{
+					// GXP[vV[PXɈ܂
+					SrcIt += EscapeTagSize;
+				}
+
+				if (!__intrinsic_isleadbyte(*SrcIt))
+					SrcIt++;
+				else
+					SrcIt += 2;
+			}
+		}
+		else
+		{
+			while (SrcIt < SrcEnd)
+			{
+				if (memcmp(SrcIt, nestStartTag.c_str(), NestStartTagSize) == 0)
+				{
+					size_t NCount;
+
+					// lXgJn
+					NCount = 1;
+					SrcIt += NestStartTagSize;
+					while (SrcIt < SrcEnd)
+					{
+						if (memcmp(SrcIt, nestStartTag.c_str(), NestStartTagSize) == 0)
+						{
+							// ɃlXg
+							SrcIt += NestStartTagSize;
+							NCount++;
+							continue;
+						}
+						if (memcmp(SrcIt, nestEndTag.c_str(), NestEndTagSize) == 0)
+						{
+							// lXg(i)
+							SrcIt += NestEndTagSize;
+							if (--NCount == 0)
+								break;	// lXgSEo
+							continue;
+						}
+						if (!__intrinsic_isleadbyte(*SrcIt))
+							SrcIt++;
+						else
+							SrcIt += 2;
+					}
+					continue;	// ɂ܂lXgJn肦ł́B
+				}
+
+				// {r
+				if (memcmp(SrcIt, Token.c_str(), TokenSize) == 0)
+					return SrcIt - Src.begin();
+
+				if (!__intrinsic_isleadbyte(*SrcIt))
+					SrcIt++;
+				else
+					SrcIt += 2;
+			}
+		}
+	}
+	else if (Option & strD::dtESCAPE)
+	{
+		// GXP[vV[PXgp
+		while (SrcIt < SrcEnd)
+		{
+			if (memcmp(SrcIt, escapeTag.c_str(), EscapeTagSize) != 0)
+			{
+				// {r
+				if (memcmp(SrcIt, Token.c_str(), TokenSize) == 0)
+					return SrcIt - Src.begin();
+			}
+			else
+			{
+				// GXP[vV[PXɈ܂
+				SrcIt += EscapeTagSize;
+			}
+			if (!__intrinsic_isleadbyte(*SrcIt))
+				SrcIt++;
+			else
+				SrcIt += 2;
+		}
+	}
+	else
+	{
+		// P
+		while (SrcIt < SrcEnd)
+		{
+			// {r
+			if (memcmp(SrcIt, Token.c_str(), TokenSize) == 0)
+				return SrcIt - Src.begin();
+
+			if (!__intrinsic_isleadbyte(*SrcIt))
+				SrcIt++;
+			else
+				SrcIt += 2;
+		}
+	}
+
+	return string::npos;
+#endif
 }
 //*********************************************************************
 //uSrcɂToken̈ʒuԂ֐̌Łv
@@ -277,6 +480,7 @@
 unsigned long TStringDivision::FindBack(const string &Src, string Token,
 	unsigned long FromIndex, unsigned long ToIndex, unsigned long Option)
 {
+#if !defined(OPTIMIZE_STRINGDIVISION) || !OPTIMIZE_STRINGDIVISION
  //n[Ε␳
  if(FromIndex>Src.size()) FromIndex = Src.size();
 
@@ -400,6 +604,202 @@
  }
 
  return string::npos;
+#else
+	size_t                 TokenLength;
+	size_t                 SrcLength;
+	string::const_iterator SrcIt, SrcEnd;
+	size_t                 NestStartTagLength;
+	size_t                 NestEndTagLength;
+	size_t                 EscapeTagLength;
+	size_t                 FindIndex;
+
+	if (ToIndex == FromIndex)
+		return string::npos;
+
+	TokenLength = Token.length();
+	SrcLength = Src.length();
+
+	// r̕ZȂĘ_O(^^;
+	if (SrcLength < TokenLength)
+		return string::npos;
+
+	// I[Ε␳
+	if (SrcLength < FromIndex || SrcLength < FromIndex + TokenLength)
+		FromIndex = SrcLength - TokenLength + 1;
+
+	SrcIt = Src.begin() + ToIndex;
+	SrcEnd = Src.begin() + FromIndex;
+
+	if (Option & strD::dtNEST)
+	{
+		NestStartTagLength = nestStartTag.length();
+		NestEndTagLength = nestEndTag.length();
+		if (NestStartTagLength == 0 || NestEndTagLength == 0)
+			return string::npos;
+	}
+	if (Option & strD::dtESCAPE)
+	{
+		EscapeTagLength = escapeTag.length();
+		if (EscapeTagLength == 0)
+			return string::npos;
+	}
+
+	// ̃p^[}b`OȂBoyer-Moore@Ď邪A
+	// 2oCglXgAGXP[vV[PXĂ̂1Â(^^;)
+
+	FindIndex = string::npos;
+	if (Option & strD::dtNEST)
+	{
+		// lXg`FbN
+		if (Option & strD::dtESCAPE)
+		{
+			// GXP[vV[PXgp
+			while (SrcIt < SrcEnd)
+			{
+				if (memcmp(SrcIt, escapeTag.c_str(), EscapeTagLength) != 0)
+				{
+					if (memcmp(SrcIt, nestStartTag.c_str(), NestStartTagLength) == 0)
+					{
+						size_t NCount;
+
+						// lXgJn
+						NCount = 1;
+						SrcIt += NestStartTagLength;
+						while (SrcIt < SrcEnd)
+						{
+							if (memcmp(SrcIt, escapeTag.c_str(), EscapeTagLength) != 0)
+							{
+								if (memcmp(SrcIt, nestStartTag.c_str(), NestStartTagLength) == 0)
+								{
+									// ɃlXg
+									SrcIt += NestStartTagLength;
+									NCount++;
+									continue;
+								}
+								if (memcmp(SrcIt, nestEndTag.c_str(), NestEndTagLength) == 0)
+								{
+									// lXg(i)
+									SrcIt += NestEndTagLength;
+									if (--NCount == 0)
+										break;	// lXgSEo
+									continue;
+								}
+							}
+							else
+							{
+								SrcIt += EscapeTagLength;
+							}
+							if (!__intrinsic_isleadbyte(*SrcIt))
+								SrcIt++;
+							else
+								SrcIt += 2;
+						}
+						continue;	// ɂ܂lXgJn肦ł́B
+					}
+
+					// {r
+					if (memcmp(SrcIt, Token.c_str(), TokenLength) == 0)
+						FindIndex = SrcIt - Src.begin();
+				}
+				else
+				{
+					// GXP[vV[PXɈ܂
+					SrcIt += EscapeTagLength;
+				}
+
+				if (!__intrinsic_isleadbyte(*SrcIt))
+					SrcIt++;
+				else
+					SrcIt += 2;
+			}
+		}
+		else
+		{
+			while (SrcIt < SrcEnd)
+			{
+				if (memcmp(SrcIt, nestStartTag.c_str(), NestStartTagLength) == 0)
+				{
+					size_t NCount;
+
+					// lXgJn
+					NCount = 1;
+					SrcIt += NestStartTagLength;
+					while (SrcIt < SrcEnd)
+					{
+						if (memcmp(SrcIt, nestStartTag.c_str(), NestStartTagLength) == 0)
+						{
+							// ɃlXg
+							SrcIt += NestStartTagLength;
+							NCount++;
+							continue;
+						}
+						if (memcmp(SrcIt, nestEndTag.c_str(), NestEndTagLength) == 0)
+						{
+							// lXg(i)
+							SrcIt += NestEndTagLength;
+							if (--NCount == 0)
+								break;	// lXgSEo
+							continue;
+						}
+						if (!__intrinsic_isleadbyte(*SrcIt))
+							SrcIt++;
+						else
+							SrcIt += 2;
+					}
+					continue;	// ɂ܂lXgJn肦ł́B
+				}
+
+				// {r
+				if (memcmp(SrcIt, Token.c_str(), TokenLength) == 0)
+					FindIndex = SrcIt - Src.begin();
+
+				if (!__intrinsic_isleadbyte(*SrcIt))
+					SrcIt++;
+				else
+					SrcIt += 2;
+			}
+		}
+	}
+	else if (Option & strD::dtESCAPE)
+	{
+		// GXP[vV[PXgp
+		while (SrcIt < SrcEnd)
+		{
+			if (memcmp(SrcIt, escapeTag.c_str(), EscapeTagLength) != 0)
+			{
+				// {r
+				if (memcmp(SrcIt, Token.c_str(), TokenLength) == 0)
+					FindIndex = SrcIt - Src.begin();
+			}
+			else
+			{
+				// GXP[vV[PXɈ܂
+				SrcIt += EscapeTagLength;
+			}
+			if (!__intrinsic_isleadbyte(*SrcIt))
+				SrcIt++;
+			else
+				SrcIt += 2;
+		}
+	}
+	else
+	{
+		// P
+		while (SrcIt < SrcEnd)
+		{
+			// {r
+			if (memcmp(SrcIt, Token.c_str(), TokenLength) == 0)
+				FindIndex = SrcIt - Src.begin();
+
+			if (!__intrinsic_isleadbyte(*SrcIt))
+				SrcIt++;
+			else
+				SrcIt += 2;
+		}
+	}
+
+	return (unsigned long)FindIndex;
+#endif
 }
 //*********************************************************************
 //uSrcɂ邢ꂩvector<string> Tokenvf̈ʒuԂ֐v
@@ -419,6 +819,7 @@
 	unsigned long *FindElementIndex,
 	unsigned long FromIndex, unsigned long ToIndex, unsigned long Option)
 {
+#if !defined(OPTIMIZE_STRINGDIVISION) || !OPTIMIZE_STRINGDIVISION
  if(FromIndex==ToIndex) return string::npos;
  {
     unsigned long SrcSize = Src.size();
@@ -480,6 +881,106 @@
  }
 
  return string::npos;
+#else
+	size_t                   SrcLength;
+	vector<string>::iterator TokenIt;
+
+	if (FromIndex == ToIndex)
+		return string::npos;
+
+	SrcLength = Src.length();
+	if (SrcLength < ToIndex)
+		ToIndex = SrcLength;
+
+	if (FindElementIndex == NULL)
+	{
+		// g[N̔ԍsv
+		if (Option == 0)
+		{
+			string::const_iterator SrcIt, SrcEnd;
+
+			// GXP[vV[PXl
+			SrcIt = Src.begin() + FromIndex;
+			SrcEnd = Src.begin() + ToIndex;
+			while (SrcIt < SrcEnd)
+			{
+				for (TokenIt = Token.begin(); TokenIt != Token.end(); TokenIt++)
+					if (memcmp(SrcIt, TokenIt->c_str(), TokenIt->length()) == 0)
+						return SrcIt - Src.begin();
+				if (!__intrinsic_isleadbyte(*SrcIt))
+					SrcIt++;
+				else
+					SrcIt += 2;
+			}
+		}
+		else
+		{
+			size_t MinPos, tmpI;
+
+			// GXP[vV[PXl
+			MinPos = string::npos;
+			for (TokenIt = Token.begin(); TokenIt != Token.end(); TokenIt++)
+			{
+				tmpI = Find(Src, *TokenIt, FromIndex, ToIndex, Option);
+				if (tmpI < MinPos)
+					MinPos = tmpI;
+			}
+			if (MinPos != string::npos)
+				return (unsigned long)MinPos;
+		}
+	}
+	else
+	{
+		if (Option == 0)
+		{
+			string::const_iterator SrcIt, SrcEnd;
+
+			// GXP[vV[PXl
+			SrcIt = Src.begin() + FromIndex;
+			SrcEnd = Src.begin() + ToIndex;
+			while (SrcIt < SrcEnd)
+			{
+				for (TokenIt = Token.begin(); TokenIt != Token.end(); TokenIt++)
+				{
+					if (memcmp(SrcIt, TokenIt->c_str(), TokenIt->length()) == 0)
+					{
+						*FindElementIndex = TokenIt - Token.begin();
+						return SrcIt - Src.begin();
+					}
+				}
+				if (!__intrinsic_isleadbyte(*SrcIt))
+					SrcIt++;
+				else
+					SrcIt += 2;
+			}
+		}
+		else
+		{
+			size_t i, MinPos, TokenNum, tmpI;
+
+			// GXP[vV[PXl
+			i = 0;
+			MinPos = string::npos;
+			for (TokenIt = Token.begin(); TokenIt != Token.end(); TokenIt++)
+			{
+				tmpI = Find(Src, *TokenIt, FromIndex, ToIndex, Option);
+				if (tmpI < MinPos)
+				{
+					MinPos = tmpI;
+					TokenNum = i;
+				}
+				i++;
+			}
+			if (MinPos != string::npos)
+			{
+				*FindElementIndex = TokenNum;
+				return (unsigned long)MinPos;
+			}
+		}
+	}
+
+	return string::npos;
+#endif
 }
 //*********************************************************************
 //uGet̒ǉ@\ɗpIvV`֐v
@@ -628,6 +1129,7 @@
 string TStringDivision::Half(string *Src, string Token, unsigned long Index,
 	unsigned long Option)
 {
+#if !defined(OPTIMIZE_STRINGDIVISION) || !OPTIMIZE_STRINGDIVISION
  if((Src==NULL)||(Src->size()<=Token.size())) return Token;
 
  unsigned long tmpI=0;
@@ -645,6 +1147,122 @@
 	return Editing(Ret, Option);
  }
  return Ret;
+#else
+	size_t     srcLength;
+	size_t     tokenLength;
+	const char *lastFound, *end, *p;
+	size_t     nest;
+	size_t     length;
+
+	if (!Src)
+		goto FAILED;
+	tokenLength = Token.length();
+	if (!tokenLength)
+		goto FAILED;
+	srcLength = Src->length();
+	if (srcLength < tokenLength)
+		goto FAILED;
+	lastFound = NULL;
+	p = Src->begin();
+	end = Src->end() - tokenLength + 1;
+	nest = 0;
+	do
+	{
+		switch (*p)
+		{
+		case '(':
+			nest++;
+			break;
+		case ')':
+			if (nest)
+				nest--;
+			break;
+		case '\\':
+			if (!(Option & strD::dtESCAPE))
+				break;
+			if (++p < end)
+				goto CHECK_LEADBYTE;
+			else
+				goto FAILED;
+		case '"':
+			if (!nest)
+				break;
+			if (++p >= end)
+				goto FAILED;
+			while (*p != '"')
+			{
+				if (*p == '\\' && ++p >= end)
+					goto FAILED;
+				if (__intrinsic_isleadbyte(*p) && ++p >= end)
+					goto FAILED;
+				if (++p >= end)
+					goto FAILED;
+			}
+			break;
+		case '<':
+			if (*(p + 1) != '#')
+				goto DEFAULT;
+			if ((p += 2) >= end)
+				goto FAILED;
+			while (*p != '#' || *(p + 1) != '>')
+			{
+				if (*p == '\\' && (Option & strD::dtESCAPE) && ++p >= end)
+					goto FAILED;
+				if (__intrinsic_isleadbyte(*p) && ++p >= end)
+					goto FAILED;
+				if (++p >= end)
+					goto FAILED;
+			}
+			if ((p += 2) < end)
+				continue;
+			else
+				goto FAILED;
+		case '!':
+			if (*(p + 1) == ']' && tokenLength == 2 && *(LPWORD)Token.c_str() == BSWAP16('!]'))
+				goto MATCHED;
+		default:
+		DEFAULT:
+			if (memcmp(p, Token.c_str(), tokenLength) != 0)
+				goto CHECK_LEADBYTE;
+			lastFound = p;
+			if (nest)
+				goto CHECK_LEADBYTE;
+		MATCHED:
+			if (!Index)
+				goto SUCCESS;
+			Index--;
+			if ((p += tokenLength) < end)
+				continue;
+			else
+				goto FAILED;
+		CHECK_LEADBYTE:
+			if (__intrinsic_isleadbyte(*p) && ++p >= end)
+				goto FAILED;
+			break;
+		}
+		p++;
+	} while (p < end);
+FAILED:
+	if (*(LPWORD)Token.c_str() == BSWAP16(':\0') && lastFound)
+	{
+		p = lastFound;
+		goto SUCCESS;
+	}
+	return Token;
+
+SUCCESS:
+	string result(Src->begin(), p - Src->begin());
+	p += tokenLength;
+	length = Src->end() - p;
+	memcpy(Src->begin(), p, length);
+	Src->resize(length);
+	if (Option & strD::etSOME_EDIT)
+	{
+		*Src = Editing(*Src, Option);
+		result = Editing(result, Option);
+	}
+	return result;
+#endif
 }
 //*********************************************************************
 //uSrcIndexԖڂTokenŔɋ؂A㔼SrcɑOԂ֐v
@@ -767,6 +1385,7 @@
 unsigned long TStringDivision::List(const string &Src, string Token,
 	vector<string> *List, unsigned long Option)
 {
+#if !defined(OPTIMIZE_STRINGDIVISION) || !OPTIMIZE_STRINGDIVISION
  vector<string> tmpL;
  unsigned long OldPos=0, NewPos,
  	SrcSize = Src.size(),
@@ -793,7 +1412,108 @@
  *List = tmpL;
 
  return tmpL.size();
+#else
+	const char *split;
+	size_t     tokenLength;
+
+	List->clear();
+	split = Src.begin();
+	if ((tokenLength = Token.length()) && Src.length() >= tokenLength)
+	{
+		const char *end, *p;
+		size_t     nest;
+
+		end = Src.end() - tokenLength + 1;
+		p = split;
+		nest = 0;
+		do
+		{
+			switch (*p)
+			{
+			case '(':
+				if (tokenLength != 3 || *(LPDWORD)Token.c_str() != BSWAP32('\'+\'\0'))
+					nest++;
+				break;
+			case ')':
+				if ((tokenLength != 3 || *(LPDWORD)Token.c_str() != BSWAP32('\'+\'\0')) && nest)
+					nest--;
+				break;
+			case '\\':
+				if (!(Option & strD::dtESCAPE))
+					break;
+				if (++p < end)
+					goto CHECK_LEADBYTE;
+				else
+					goto NESTED_BREAK;
+			case '"':
+				if (!nest)
+					break;
+				if (++p >= end)
+					goto NESTED_BREAK;
+				while (*p != '"')
+				{
+					if (*p == '\\' && ++p >= end)
+						goto NESTED_BREAK;
+					if (__intrinsic_isleadbyte(*p) && ++p >= end)
+						goto NESTED_BREAK;
+					if (++p >= end)
+						goto NESTED_BREAK;
+				}
+				break;
+			case '<':
+				if (*(p + 1) != '#')
+					goto DEFAULT;
+				if ((p += 2) >= end)
+					goto NESTED_BREAK;
+				while (*p != '#' || *(p + 1) != '>')
+				{
+					if (*p == '[' && *(p + 1) == '!' && tokenLength == 2 && *(LPWORD)Token.c_str() == BSWAP16('[!'))
+						goto MATCHED;
+					if (*p == '\\' && (Option & strD::dtESCAPE) && ++p >= end)
+						goto NESTED_BREAK;
+					if (__intrinsic_isleadbyte(*p) && ++p >= end)
+						goto NESTED_BREAK;
+					if (++p >= end)
+						goto NESTED_BREAK;
+				}
+				if ((p += 2) < end)
+					continue;
+				else
+					goto NESTED_BREAK;
+			case '[':
+				if (*(p + 1) == '!' && tokenLength == 2 && *(LPWORD)Token.c_str() == BSWAP16('[!'))
+					goto MATCHED;
+			default:
+			DEFAULT:
+				if (nest)
+					goto CHECK_LEADBYTE;
+				if (memcmp(p, Token.c_str(), tokenLength) == 0)
+				{
+			MATCHED:
+					string s(split, p - split);
+					if (Option & strD::etSOME_EDIT)
+						s = Editing(s, Option);
+					List->push_back(s);
+					split = (p += tokenLength);
+					continue;
+				}
+			CHECK_LEADBYTE:
+				if (__intrinsic_isleadbyte(*p) && ++p >= end)
+					goto NESTED_BREAK;
+				break;
+			}
+			p++;
+		} while (p < end);
+	}
+NESTED_BREAK:
+	string s(split, Src.end() - split);
+	if (Option & strD::etSOME_EDIT)
+		s = Editing(s, Option);
+	List->push_back(s);
+	return List->size();
+#endif
 }
+#if !defined(OPTIMIZE_STRINGDIVISION) || !OPTIMIZE_STRINGDIVISION
 //*********************************************************************
 //uSrc2oCgluꕶvʂɁAvector<string> ListɊi[֐v
 //
@@ -827,6 +1547,7 @@
 
  return tmpL.size();
 }
+#endif
 //*********************************************************************
 //uList̊evfTokenŌqԂ֐v
 //
@@ -1000,8 +1721,116 @@
 //	Remove("ab-cd-ef", "-", "..")	=	"ab..cd..ef"
 //	Remove("ab-cd-ef", "-", "")		=	"abcdef"
 //*********************************************************************
+#if defined(OPTIMIZE_STRINGDIVISION) && OPTIMIZE_STRINGDIVISION
+void TStringDivision_Remove(string &Target, const string &Token, char *Dest, unsigned long Option)
+{
+	size_t tokenLength;
+
+	tokenLength = Token.length();
+	if (tokenLength != 0)
+	{
+		LPSTR  p;
+		size_t destLength;
+
+		p = Target.begin();
+		destLength = Dest != NULL ? strlen(Dest) : 0;
+		if (destLength == tokenLength)
+		{
+			while (p < Target.end())
+			{
+				if (memcmp(p, Token.c_str(), destLength) == 0)
+				{
+					memcpy(p, Dest, destLength);
+					p += destLength;
+				}
+				else if (!__intrinsic_isleadbyte(*p))
+					p++;
+				else
+					p += 2;
+			}
+		}
+		else
+		{
+			size_t targetLength;
+
+			targetLength = Target.length();
+			if (destLength < tokenLength)
+			{
+				if (destLength == 0)
+				{
+					while (p < Target.end())
+					{
+						if (memcmp(p, Token.c_str(), tokenLength) == 0)
+						{
+							LPSTR  copySrc;
+							LPCSTR moveableMemBlock;
+
+							copySrc = p + tokenLength;
+							memcpy(p += destLength, copySrc, Target.end() - copySrc);
+							moveableMemBlock = Target.c_str();
+							Target.resize(targetLength -= tokenLength);
+							p += Target.c_str() - moveableMemBlock;
+						}
+						else if (!__intrinsic_isleadbyte(*p))
+							p++;
+						else
+							p += 2;
+					}
+				}
+				else
+				{
+					while (p < Target.end())
+					{
+						if (memcmp(p, Token.c_str(), tokenLength) == 0)
+						{
+							LPSTR  copySrc;
+							LPCSTR moveableMemBlock;
+
+							memcpy(p, Dest, destLength);
+							copySrc = p + tokenLength;
+							memcpy(p += destLength, copySrc, Target.end() - copySrc);
+							moveableMemBlock = Target.c_str();
+							Target.resize(targetLength -= tokenLength - destLength);
+							p += Target.c_str() - moveableMemBlock;
+						}
+						else if (!__intrinsic_isleadbyte(*p))
+							p++;
+						else
+							p += 2;
+					}
+				}
+			}
+			else
+			{
+				while (p < Target.end())
+				{
+					if (memcmp(p, Token.c_str(), tokenLength) == 0)
+					{
+						LPCSTR moveableMemBlock;
+						LPSTR  moveDest;
+
+						moveableMemBlock = Target.c_str();
+						Target.resize(targetLength += destLength - tokenLength);
+						p += Target.c_str() - moveableMemBlock;
+						moveDest = p + destLength;
+						memmove(moveDest, p + tokenLength, Target.end() - moveDest);
+						memcpy(p, Dest, destLength);
+						p = moveDest;
+					}
+					else if (!__intrinsic_isleadbyte(*p))
+						p++;
+					else
+						p += 2;
+				}
+			}
+		}
+	}
+}
+//---------------------------------------------------------------------------
+#endif
 string TStringDivision::Remove(const string &Src, string Token, char *Dest, unsigned long Option)
 {
+#if !defined(OPTIMIZE_STRINGDIVISION) || !OPTIMIZE_STRINGDIVISION
  unsigned long NewPos = Find(Src, Token, 0, string::npos, Option);
  if((size_t)NewPos==string::npos) return Src;
 
@@ -1024,6 +1853,12 @@
  }
 
  return Ret + Src.substr(OldPos, string::npos);
+#else
+	string result;
+
+	TStringDivision_Remove(result = Src, Token, Dest, Option);
+	return result;
+#endif
 }
 //*********************************************************************
 //uSrćReplaceMapɂfirstSđΉ
@@ -1048,9 +1883,77 @@
 //	ReplaceMap{ {"-", ""} }
 //	Remove("ab-cd-ef", &ReplaceMap)	=	"abcdef"
 //*********************************************************************
+#if defined(OPTIMIZE_STRINGDIVISION) && OPTIMIZE_STRINGDIVISION
+void TStringDivision_RemoveByMap(string &Target, map<string, string> *ReplaceMap, unsigned long Option)
+{
+	size_t targetLength;
+	LPSTR  p;
+
+	targetLength = Target.length();
+	p = Target.begin();
+	while (p < Target.end())
+	{
+		map<string, string>::iterator it;
+
+		it = ReplaceMap->end();
+		do
+		{
+			size_t tokenLength;
+			size_t destLength;
+
+			it--;
+			tokenLength = it->first.length();
+			if (tokenLength == 0)
+				continue;
+			if (memcmp(p, it->first.c_str(), tokenLength) != 0)
+				continue;
+			destLength = it->second.length();
+			if (destLength == tokenLength)
+			{
+				memcpy(p, it->second.c_str(), destLength);
+				p += destLength;
+			}
+			else if (destLength < tokenLength)
+			{
+				LPSTR  copySrc;
+				LPCSTR moveableMemBlock;
+
+				if (destLength != 0)
+					memcpy(p, it->second.c_str(), destLength);
+				copySrc = p + tokenLength;
+				memcpy(p += destLength, copySrc, Target.end() - copySrc);
+				moveableMemBlock = Target.c_str();
+				Target.resize(targetLength -= tokenLength - destLength);
+				p += Target.c_str() - moveableMemBlock;
+			}
+			else
+			{
+				LPCSTR moveableMemBlock;
+				LPSTR  moveDest;
+
+				moveableMemBlock = Target.c_str();
+				Target.resize(targetLength += destLength - tokenLength);
+				p += Target.c_str() - moveableMemBlock;
+				moveDest = p + destLength;
+				memmove(moveDest, p + tokenLength, Target.end() - moveDest);
+				memcpy(p, it->second.c_str(), destLength);
+				p = moveDest;
+			}
+			goto NESTED_CONTINUE;
+		} while (it != ReplaceMap->begin());
+		if (!__intrinsic_isleadbyte(*p))
+			p++;
+		else
+			p += 2;
+	NESTED_CONTINUE:;
+	}
+}
+//---------------------------------------------------------------------------
+#endif
 string TStringDivision::Remove(const string &Src,
 	map<string,	string> *ReplaceMap, unsigned long Option)
 {
+#if !defined(OPTIMIZE_STRINGDIVISION) || !OPTIMIZE_STRINGDIVISION
  if(!(Option&strD::etREPLACE)) return Src;
 
  if(ReplaceMap==NULL) ReplaceMap = &replaceMap;
@@ -1103,6 +2006,16 @@
  }
 
  return Dest;
+#else
+	string result;
+
+	if (ReplaceMap == NULL)
+		ReplaceMap = &replaceMap;
+	result = Src;
+	if (!ReplaceMap->empty())
+		TStringDivision_RemoveByMap(result, ReplaceMap, Option);
+	return result;
+#endif
 }
 //*********************************************************************
 //uSrc̑OɂTrimSet̗vfSďԂ֐v
@@ -1114,8 +2027,131 @@
 //	Trim(" A	B@Cde 	")	=	"A	B@Cde"
 //	//ɂłA"1oCgA^uB2oCgCde1oCgx2"ł
 //*********************************************************************
+#if defined(OPTIMIZE_STRINGDIVISION) && OPTIMIZE_STRINGDIVISION
+void TStringDivision_Trim(string &Target, set<string> &TrimSet, unsigned long Option)
+{
+	if ((Option & strD::etTRIM) && !Target.empty())
+	{
+		LPCSTR begin;
+
+		begin = Target.begin();
+		if (Option & strD::etTRIM_L)
+		{
+			do
+			{
+				set<string>::iterator it;
+
+				it = TrimSet.end();
+				do
+				{
+					size_t length;
+
+					it--;
+					if (memcmp(begin, it->c_str(), length = it->length()) == 0)
+					{
+						begin += length;
+						goto NESTED_CONTINUE1;
+					}
+				} while (it != TrimSet.begin());
+				break;
+			NESTED_CONTINUE1:;
+			} while (begin < Target.end());
+		}
+		if ((Option & strD::etTRIM_R) && Target.end() > begin)
+		{
+			BOOL                  reverseScan;
+			set<string>::iterator it;
+			LPCSTR                end;
+
+			reverseScan = TRUE;
+			it = TrimSet.end();
+			do
+			{
+				it--;
+				if (it->length() > 1 || __intrinsic_istailbyte(*it->c_str()))
+				{
+					reverseScan = FALSE;
+					break;
+				}
+			} while (it != TrimSet.begin());
+			end = NULL;
+			if (reverseScan)
+			{
+				LPCSTR p;
+
+				p = Target.end();
+				do
+				{
+					char ch;
+
+					ch = *--p;
+					it = TrimSet.end();
+					do
+					{
+						if (*(--it)->c_str() == ch)
+							goto NESTED_CONTINUE2;
+					} while (it != TrimSet.begin());
+					break;
+				NESTED_CONTINUE2:;
+				} while ((end = p) > begin);
+			}
+			else
+			{
+				LPCSTR p;
+
+				p = begin;
+				do
+				{
+					set<string>::iterator it;
+
+					it = TrimSet.end();
+					do
+					{
+						size_t length;
+
+						it--;
+						if (memcmp(p, it->c_str(), length = it->length()) == 0)
+						{
+							if (end == NULL)
+								end = p;
+							p += length;
+							goto NESTED_CONTINUE3;
+						}
+					} while (it != TrimSet.begin());
+					end = NULL;
+					if (!__intrinsic_isleadbyte(*p))
+						p++;
+					else
+						p += 2;
+				NESTED_CONTINUE3:;
+				} while (p < Target.end());
+			}
+			if (end != NULL)
+			{
+				size_t length;
+
+				length = end - begin;
+				if (begin != Target.begin())
+					memcpy(Target.begin(), begin, length);
+				Target.resize(length);
+				return;
+			}
+		}
+		if (begin != Target.begin())
+		{
+			size_t length;
+
+			length = Target.end() - begin;
+			memcpy(Target.begin(), begin, length);
+			Target.resize(length);
+		}
+	}
+}
+//---------------------------------------------------------------------------
+#endif
 string TStringDivision::Trim(const string &Src, set<string> &TrimSet, unsigned long Option)
 {
+#if !defined(OPTIMIZE_STRINGDIVISION) || !OPTIMIZE_STRINGDIVISION
  if(Src.empty()) return "";	//󂩂B
 
  unsigned long SrcSize = Src.size();
@@ -1161,6 +2197,12 @@
 	}
  }
  return Src.substr(SPos, EPos-SPos+1);
+#else
+	string result;
+
+	TStringDivision_Trim(result = Src, TrimSet, Option);
+	return result;
+#endif
 }
 //*********************************************************************
 //uSrcSď/啶ɂԂ֐v
@@ -1179,8 +2221,14 @@
  string::iterator
 	SrcIt  = Src.begin()+Start,
  	SrcEnd = Src.begin()+End;
+#if !defined(OPTIMIZE_STRINGDIVISION) || !OPTIMIZE_STRINGDIVISION
  for(; SrcIt!=SrcEnd; SrcIt++){
 	if(IsHeadByte(Src, SrcIt)==0)
+#else
+ for (; SrcIt < SrcEnd; SrcIt++)
+ {
+	if (!__intrinsic_isleadbyte(*SrcIt))
+#endif
 		*SrcIt=tolower(*SrcIt);
 	else
 		SrcIt++;	//for[v̉Zƍ킹A2oCg߂(ύXȂ)
@@ -1194,8 +2242,14 @@
  string::iterator
 	SrcIt  = Src.begin()+Start,
  	SrcEnd = Src.begin()+End;
+#if !defined(OPTIMIZE_STRINGDIVISION) || !OPTIMIZE_STRINGDIVISION
  for(; SrcIt!=SrcEnd; SrcIt++){
 	if(IsHeadByte(Src, SrcIt)==0)
+#else
+ for (; SrcIt < SrcEnd; SrcIt++)
+ {
+	if (!__intrinsic_isleadbyte(*SrcIt))
+#endif
 		*SrcIt=toupper(*SrcIt);
 	else
 		SrcIt++;	//for[v̉Zƍ킹A2oCg߂(ύXȂ)
@@ -1330,6 +2384,7 @@
  _snprintf(tmpC, 255, ((Format==NULL)||(_isnan(Src)!=0))?"%f":Format, Src);
  return (string)tmpC;
 }
+#if !defined(OPTIMIZE_STRINGDIVISION) || !OPTIMIZE_STRINGDIVISION
 //*********************************************************************
 //uSrcStart͈(Min<=X<=MAX)̕Ԃ֐v
 //
@@ -1394,6 +2449,7 @@
 
  return Result;
 }
+#endif
 //*********************************************************************
 //u̕񂪓`Ԃ֐v
 //
@@ -1412,6 +2468,7 @@
 bool TStringDivision::WCList(const string &Val1, const string &Val2,
 	vector<string> *List1, vector<string> *List2)
 {
+#if !defined(OPTIMIZE_STRINGDIVISION) || !OPTIMIZE_STRINGDIVISION
  unsigned long Val1Size=Val1.size();
  unsigned long Val2Size=Val2.size();
  unsigned long Val1Pos=0, Val2Pos=0;
@@ -1590,6 +2647,333 @@
  if(List2!=NULL) *List2 = tmpV2;
 
  return Ret;
+#else
+	size_t  Val1Length;
+	size_t  Val2Length;
+	size_t  Val1Pos, Val2Pos;
+	string  StockS1, StockS2;
+	BOOLEAN Ret;
+
+	if (List1 != NULL)
+		List1->clear();
+	if (List2 != NULL)
+		List2->clear();
+	Val1Length = Val1.length();
+	Val2Length = Val2.length();
+	Val1Pos = 0, Val2Pos = 0;
+	Ret = TRUE;
+	for (; Val1Pos < Val1Length; Val1Pos++)
+	{
+		size_t charLength;
+		char   PosVal;
+
+		PosVal = Val1[Val1Pos];
+		if (!__intrinsic_isleadbyte(PosVal))
+		{
+			if (PosVal == '*')
+			{
+				string NextWord;
+				size_t FindPos;
+				size_t NextPos;
+				size_t QCount;
+
+				if (!StockS1.empty())
+				{
+					// ܂ł̕񂪈vȂApush
+					if (StockS1 != StockS2)
+					{
+						Ret = FALSE;
+						break;
+					}
+					if (List1 != NULL)
+						List1->push_back(StockS1);
+					if (List2 != NULL)
+						List2->push_back(StockS2);
+				}
+				StockS1 = "*";
+				StockS2.clear();
+
+				FindPos = string::npos;
+				NextPos = Val1Pos;
+				QCount = 0;	// '?'̘A
+				while (++NextPos < Val1Length)
+				{
+					PosVal = Val1[NextPos];
+					if (!__intrinsic_isleadbyte(PosVal))
+					{
+						if (PosVal == '*')
+						{
+							StockS1 += '*';
+						}
+						else if (PosVal == '?')
+						{
+							StockS1 += '?';
+							QCount++;
+						}
+						else
+						{
+							FindPos = NextPos;
+							break;
+						}
+					}
+					else
+					{
+						FindPos = NextPos;
+						break;
+					}
+					Val1Pos = NextPos;
+				}
+				if (FindPos != string::npos)
+				{
+					size_t TailPos;
+					size_t length;
+
+					for (TailPos = FindPos; TailPos < Val1Length; TailPos++)
+					{
+						char ch;
+
+						ch = Val1[TailPos];
+						if (!__intrinsic_isleadbyte(ch))
+						{
+							if (ch == '*' || ch == '?')
+								break;
+						}
+						else
+						{
+							TailPos++;
+						}
+					}
+					NextWord.resize(length = TailPos - FindPos);
+					memcpy(NextWord.begin(), Val1.begin() + FindPos, length);
+				}
+
+				if (QCount)
+				{
+					// '?'Ƃ̕pȂ
+					while (Val2Pos < Val2Length)
+					{
+						if (!__intrinsic_isleadbyte(Val2[Val2Pos]))
+							StockS2 += Val2[Val2Pos++];
+						else
+						{
+							size_t pos;
+
+							// 2oCg
+							StockS2.resize((pos = StockS2.length()) + 2);
+							*(LPWORD)(StockS2.begin() + pos) = *(LPWORD)(Val2.begin() + Val2Pos);
+							Val2Pos += 2;
+						}
+
+						if (--QCount == 0)
+							break;
+					}
+					if (QCount)
+					{
+						// Val2͏I[B'?'ĂȂI
+						Ret = FALSE;
+						// r[v𔲂
+						break;
+					}
+				}
+
+				if (NextWord.empty())
+				{
+					size_t pos, length;
+
+					// ꂪȂ=Ō܂'?''*'
+					// (A'?'̌͓Kpς)
+					StockS2.resize((pos = StockS2.length()) + (length = Val2Length - Val2Pos));
+					memcpy(StockS2.begin() + pos, Val2.begin() + Val2Pos, length);
+					Val2Pos = Val2Length;
+				}
+				else
+				{
+					size_t WordPos;
+					size_t pos, length;
+
+					WordPos = Find(Val2, NextWord, Val2Pos);
+					if (WordPos == (unsigned long)string::npos)
+					{
+						// 𔭌łȂ
+						Ret = FALSE;
+						// r[v𔲂
+						break;
+					}
+					StockS2.resize((pos = StockS2.length()) + (length = WordPos - Val2Pos));
+					memcpy(StockS2.begin() + pos, Val2.begin() + Val2Pos, length);
+
+					Val2Pos = WordPos;
+				}
+
+				if (List1 != NULL)
+					List1->push_back(StockS1);
+				if (List2 != NULL)
+					List2->push_back(StockS2);
+				StockS1.clear();
+				StockS2.clear();
+				continue;
+			}
+			else if (PosVal == '?')
+			{
+				size_t QCount;
+				size_t pos;
+
+				if (!StockS1.empty())
+				{
+					// ܂ł̕񂪈vȂApush
+					if (StockS1 != StockS2)
+					{
+						Ret = FALSE;
+						break;
+					}
+					if (List1 != NULL)
+						List1->push_back(StockS1);
+					if (List2 != NULL)
+						List2->push_back(StockS2);
+					StockS1.clear();
+					StockS2.clear();
+				}
+
+				QCount = 1;	// '?'̘A
+				while (++Val1Pos < Val1Length)
+				{
+					if (Val1[Val1Pos] != '?')
+					{
+						// '?'AĂȂȂ
+						Val1Pos--;
+						break;
+					}
+					QCount++;
+				}
+
+				// KvA'?'ǉ
+				StockS1.resize((pos = StockS1.length()) + QCount);
+				memset(StockS1.begin() + pos, '?', QCount);
+
+				while (Val2Pos < Val2Length)
+				{
+					if (!__intrinsic_isleadbyte(Val2[Val2Pos]))
+						StockS2 += Val2[Val2Pos++];
+					else
+					{
+						size_t pos;
+
+						// 2oCg
+						StockS2.resize((pos = StockS2.length()) + 2);
+						*(LPWORD)(StockS2.begin() + pos) = *(LPWORD)(Val2.begin() + Val2Pos);
+						Val2Pos += 2;
+					}
+
+					if (--QCount == 0)
+						break;
+				}
+
+				if (QCount)
+				{
+					BOOL EndFlag;
+
+					// Val2͏I[BVal1̎c'*'H
+					EndFlag = FALSE;
+					for (++Val1Pos; Val1Pos < Val1Length; Val1Pos++)
+					{
+						PosVal = Val1[Val1Pos];
+						if (PosVal != '*')
+						{
+							EndFlag = TRUE;
+							break;
+						}
+						StockS1 += '*';
+					}
+					// Ō܂'*'ȂAVal1PosVal1Length͊ɓ(LoopEo)
+					if (EndFlag)
+					{
+						Ret = FALSE;
+						// r[v𔲂
+						break;
+					}
+				}
+
+				if (List1 != NULL)
+					List1->push_back(StockS1);
+				if (List2 != NULL)
+					List2->push_back(StockS2);
+				StockS1.clear();
+				StockS2.clear();
+				continue;
+			}
+			else
+			{
+				if (PosVal != Val2[Val2Pos])
+				{
+					Ret = FALSE;
+					break;
+				}
+			}
+			charLength = 1;
+		}
+		else
+		{
+			if (PosVal != Val2[Val2Pos] || Val1[Val1Pos + 1] != Val2[Val2Pos + 1])
+			{
+				Ret = FALSE;
+				break;
+			}
+			charLength = 2;
+		}
+
+		for (; ; )
+		{
+			StockS1 += PosVal;
+			StockS2 += Val2[Val2Pos++];
+
+			if (Val2Pos >= Val2Length)
+			{
+				// Val2͏I[BVal1̎c'*'H
+				if (List1 != NULL)
+					List1->push_back(StockS1);
+				if (List2 != NULL)
+					List2->push_back(StockS2);
+				StockS1.clear();
+				StockS2.clear();
+
+				for (++Val1Pos; Val1Pos < Val1Length; Val1Pos++)
+				{
+					PosVal = Val1[Val1Pos];
+					if (PosVal != '*')
+					{
+						Ret = FALSE;
+						break;
+					}
+					StockS1 += '*';
+				}
+				goto NESTED_BREAK;
+			}
+			if (!--charLength)
+				break;
+			Val1Pos++;
+		}
+	}
+NESTED_BREAK:
+
+	if (Ret)
+	{
+		// ܂vĂƂAcr
+		if ((StockS1 == StockS2) && (Val2Pos >= Val2Length))
+		{
+			if (!StockS1.empty())
+			{
+				if (List1 != NULL)
+					List1->push_back(StockS1);
+				if (List2 != NULL)
+					List2->push_back(StockS2);
+			}
+		}
+		else
+			Ret = FALSE;
+	}
+
+	return Ret;
+#endif
 }
 //*********************************************************************
 //uAw萔ƂɕĊi[xN^Ԃ֐v
@@ -1699,6 +3083,7 @@
 			NowWordPriority = (*StackTopIT).second.first;
 			NowWordType = (*StackTopIT).second.second;
 
+#if !defined(SPOILERAL_FIX_STRINGDIVISION_POSTFIX_071003_IYA) || !SPOILERAL_FIX_STRINGDIVISION_POSTFIX_071003_IYA
             if(NowWordType==strD::osCLOSE+strD::osPUSH){
                 StackTopPriority=-1, StackTopType=strD::osOPEN;
                 while( NestStack.top()!=0 && FactorStack.top()!="" ){
@@ -1708,6 +3093,38 @@
                     NestStack.top()--;
                 }
                 RVec.push_back(NowWord);
+#else
+			// strD::osPUSH Ȃە( `)' )Zqŏ悤ύX -- iya
+			if(NowWordType & strD::osCLOSE){	// if(NowWordType==strD::osCLOSE+strD::osPUSH){
+				// StackTopPriority, StackTopType  -1, strD::osOPEN ȊO̒lɂȂ蓾̂, while [vIɐl悤ύX
+				// Ƃ, `1 * (2) + 3' Ƃ `)' 鎞_ł, FactorStack  `*' ݂, StackTopPriority  -1 ɐݒ肵Ă܂,
+				//  `+' Ƃ, `+' ̂قZq̗D揇ʂƔfĂ܂, `*' ŌɊҌ(RVec ɃvbV)ƂɂȂĂ܂܂ -- iya
+                // StackTopPriority=-1, StackTopType=strD::osOPEN;
+
+				// FactorStack ̃vbV, |bvɂ킹, NestStack.top() ̒l𑝌Ă̂, 㔼͕̏svȂ͂.
+				// ƂƂ, oCixł̃pb`ł, StackTop n̕ϐXVޏꏊmۂ邽߂, 㔼̏Ă܂.
+				// \[XR[hxł, ŜߎcĂق悢Ǝv̂, ̂܂܂ɂĂ܂ -- iya
+            	while( NestStack.top()!=0  && FactorStack.top()!="" ){
+					// StackTopIT ̒l, while [vI, StackTopPriority, StackTopType Ƃ킹Ď擾̂, RgAEg -- iya
+                    // StackTopIT = Operator.find(FactorStack.top());
+    	        	RVec.push_back( FactorStack.top() );
+        	    	FactorStack.pop();
+                    NestStack.top()--;
+                }
+				// StackTop n̕ϐXV. ̎_ StackTopIT  NotOperator ɂȂ邱Ƃ͂肦Ȃ(ɉZqł)͂Ȃ̂, `if(StackTopIT==NotOperator)' ̏͏ȂĂ܂. ͈ؖȉ̒ʂł.
+				// 1. Iyh͂ǂ̉ZqD揇ʂ悤`Ă(TSSTCtrl/SSGCtrl.cpp QƂ̂)̂, ɍŏɑ݂Iyh, KFactorStack ɐς܂(
+				//    `NowWordPriority <= StackTopPriority' ,  while 肪ɋUƂȂ邩). ܂, ̎_StackTopPriority = SIGNED_CHAR_MAX = 127, NestStack.top() > 1 ɂȂ.
+				// 2. 1691 sڂ for ̏(`i<Size') FactorStack ̃gbvɃIyhꍇ,  NowWord Ȃł,  for ̏肪sƂɂ, ̃Iyh FactorStack 菜Ă(
+				//     while [v,  while [vŊҌ).
+				// 3. 1, 2 , FactorStack ɂ͍X 1̃Iyh݂, ݂ꍇł FactorStack ̃gbv̈ʒuɂ.
+				// 4. 2, 3 , ɂ StackTop n̕ϐXVɂ FactorStack ɃIyh܂݂Ȃ(for ̏莞 FactorStack ̃gbvɃIyh݂ꍇ while [vŊҌ邩).
+				//
+				// L 4Ƃ, oCipb`̃TCY팸̂, 폜Ă܂, \[XR[hxł, Ŝߏsق悢܂ -- iya
+				StackTopIT = Operator.find(FactorStack.top()); StackTopPriority = (*StackTopIT).second.first, StackTopType = (*StackTopIT).second.second;
+
+				// strD::osPUSH 𑮐ƂĎȂʂꊇď悤ύX̂, NowWord  RVec ɃvbVOɑmF -- iya
+				if(NowWordType & strD::osPUSH) RVec.push_back(NowWord);
+#endif
 
                 NestStack.pop();
                 continue;
@@ -1725,8 +3142,18 @@
 		}
 	}
 
+#if !defined(SPOILERAL_FIX_STRINGDIVISION_POSTFIX_071003_IYA) || !SPOILERAL_FIX_STRINGDIVISION_POSTFIX_071003_IYA
 	while( ((NowWordPriority<=StackTopPriority) && ((StackTopType&strD::osOPEN)==0))
             || (StackTopType==strD::osCLOSE+strD::osPUSH) ){
+#else
+	// strD::osOPEN ł鉉Zq, strD::osPUSH Ȃ悤ł̂, `(StackTopType&strD::osOPEN)==0' ͍̏폜܂. oCipb`̃TCYk̂߂ɍ̂ŕKvȂ𕜊Ă.
+	// strD::osCLOSE ł鉉Zq, NowWord ̎_ŏ̂, StackTopType  strD::osCLOSE Ƃ͂肦ȂƔf, `StackTopType==strD::osCLOSE+strD::osPUSH' ͍̏폜܂.
+	// `NestStack.top() != 0' ̏ǉ܂. ʂɂD揇ʂ̕ύXsȂő̌, ݂̏ȂƂƎv܂.
+ 	// Ƃ, `3 * (2 + 1)' Ƃ `+' 鎞,  while [v 1xڂ Iyh 2 Ҍ, 2xڂ NowWord = '+', StackTop = '*' ̏Ԃŏ肪s邱ƂɂȂ܂.
+ 	// ̂Ƃ, NestStack.top() ̒l(̎_ł 0)lȂ, D揇ʂ̍ `*' Ҍ(`3 * 2' ɉZ)܂܂ -- iya
+	while( NowWordPriority <= StackTopPriority && NestStack.top() != 0 ){	/* while( ((NowWordPriority<=StackTopPriority) && ((StackTopType&strD::osOPEN)==0))
+            || (StackTopType==strD::osCLOSE+strD::osPUSH) ){ */
+#endif
 		RVec.push_back( FactorStack.top() );
 		FactorStack.pop();
 
@@ -1740,7 +3167,12 @@
 			StackTopType = (*StackTopIT).second.second;
 		}
 	}
+#if !defined(SPOILERAL_FIX_STRINGDIVISION_POSTFIX_071003_IYA) || !SPOILERAL_FIX_STRINGDIVISION_POSTFIX_071003_IYA
 	if( (NowWordType&strD::osCLOSE)!=0 ){
+#else
+ 	// ׂĂ̕ʂŏ悤ɕύX̂, ̏Iɍ폜 -- iya
+ 	if(0){	// if( (NowWordType&strD::osCLOSE)!=0 ){
+#endif
         //ʑ
 
    		//stOȂȂʂ
@@ -1759,6 +3191,9 @@
             StackTopType = strD::osPUSH;
             StackTopPriority = 127;
         }else{
+#if defined(SPOILERAL_FIX_STRINGDIVISION_POSTFIX_071003_IYA) && SPOILERAL_FIX_STRINGDIVISION_POSTFIX_071003_IYA
+			// StackTopType  StackTopPriority ̑tɂȂĂ܂(second.first  Priority , second.second  Type `Ă͂ł). ͍̕폜̂ňȉ̕͏CĂ܂ -- iya
+#endif
             StackTopType = (*StackTopIT).second.first;
             StackTopPriority = (*StackTopIT).second.second;
         }
