fix: 修正一些逻辑

src/include/wxss.h

@@ -157,6 +157,7 @@ namespace WXSS
             std::vector<std::shared_ptr<WXSS::CSSTreeLib::Rule>> offset_4_vecPtr;
             std::vector<std::pair<std::string, std::shared_ptr<WXSS::CSSTreeLib::Rule>>> offset_4_vecPair;
             std::vector<std::string> offset_4_vecStr;
+            std::shared_ptr<WXSS::CSSTreeLib::Rule> offset_4_ptr;
             // ~Rule();
         };
 

src/wxml/rewrite.cpp

@@ -231,8 +231,11 @@ namespace WXML {
             return ToStringCode3(src.data(), src.size());
         }
         
+        int GetToken_i = 0;
         void GetToken(std::string const& a1,std::vector<std::pair<int,std::string>> & a2)
         {
+            GetToken_i++;
+            int inner_GetToken_i = GetToken_i;
             for (int i = 0; i < a1.length(); )
             {
                 int v9 = a1.length() - i;
@@ -255,7 +258,7 @@ namespace WXML {
                         }
                     }
                 }
-                std::string v10(a1.begin() + i, a1.end() - 9);
+                std::string v10(a1.begin() + i, a1.end() - v9);
                 a2.push_back(std::make_pair(lt, v10));
                 i = a1.length() - v9;
 
@@ -341,10 +344,51 @@ namespace WXML {
 
             return result;
         }
-        int RewriteRPX(std::string const&,std::string&,char const*,char const*)
+        int RewriteRPX(std::string const& a1, std::string& a2, char const* a3, char const* a4)
         {
+            std::vector<std::pair<WXML::STRTOKEN, std::string>> v22;
+            WXML::Rewrite::GetToken(a1, v22);
+            a2 = "";
+            bool v17 = true;
+            for (int i = 1; i < v22.size(); i++)
+            {
+                auto cur = v22[i];
+                if (v22[i - 1].first == 1 && !cur.first && !cur.second.compare("rpx"))
+                {
+                    std::string v29 = a4;
+                    std::string v25 = a3;
+                    v25.append(v22[i - 1].second);
+                    v25.append(v22[i].second);
+                    // int v8 = v25.length() + v29.length();
+                    v25.append(v29);
+                    a2 += v25;
+                    if (++i == v22.size())
+                    {
+                        v17 = false;
+                    }
+                }
+                else
+                {
+                    a2 += v22[i - 1].second;
+                }
+            }
+            if (v22.begin() != v22.end() && v17)
+            {
+                a2 += v22.back().second;
+            }
+            if (a2.length() == a1.length())
+            {
+                if (a2.length())
+                {
+                    return a2 != a1;
+                }
+                return 0;
+            }
+            else
+            {
+                return 1;
+            }
             
-            throw "not implement";
         }
     }
 }

src/wxml/rpx.cpp

@@ -832,8 +832,8 @@ namespace WXML
             int i;
             for (i = a3; i > 0; i--)
             {
-                int v7 = v4;
+                v7 = v4;
-                v4 = a1[266 * v4 + *a4];
+                v4 = a1[266 * v4 + *a4]; // 266 * 4 = 0x428
                 if (v4 == -1)
                 {
                     break;
@@ -841,7 +841,7 @@ namespace WXML
                 a4++;
             }
 
-            if (a2[v7])
+            if (((char *)a2)[v7])
             {
                 a3 = i;
                 return 0;

src/wxss/css_tree_lib/css_syntax_tree.cpp

@@ -21,7 +21,7 @@ namespace WXSS
             {
                 if (!this->offset_172)
                 {
-                    if (this->offset_132 && a3)
+                    if (this->offset_132.get() && a3)
                     {
                         a2 += *this->offset_132;
                     }

src/wxss/css_tree_lib/lexical_checker.cpp

@@ -10,9 +10,9 @@ namespace WXSS
     namespace CSSTreeLib
     {
         
+        // WXSS::CSSTreeLib::MarkHostRule::MarkGood
         int off_519A58(std::shared_ptr<WXSS::CSSTreeLib::Rule>& a1, std::shared_ptr<WXSS::CSSTreeLib::CSSSyntaxTree> &a2)
         {
-            // WXSS::CSSTreeLib::MarkHostRule::MarkGood
             for (auto lt = a2->offset_120.begin(); lt != a2->offset_120.end(); lt++)
             {
                 if (lt->get()->offset_0 == "SELECTORS")
@@ -73,9 +73,10 @@ namespace WXSS
             
             return 1;
         }
+    
+        // WXSS::CSSTreeLib::AttrDebugRule::MarkGood
         int off_519A70(std::shared_ptr<WXSS::CSSTreeLib::Rule>& a1, std::shared_ptr<WXSS::CSSTreeLib::CSSSyntaxTree> &a2)
         {
-            // WXSS::CSSTreeLib::AttrDebugRule::MarkGood
             auto v9 = a2->offset_168;
             std::shared_ptr<WXSS::CSSTreeLib::CSSSyntaxTree> la(new WXSS::CSSTreeLib::CSSSyntaxTree());
             std::stringstream v26;
@@ -130,9 +131,10 @@ namespace WXSS
             }
             return v13;
         }
+    
+        // WXSS::CSSTreeLib::BlackListRule::MarkGood
         int off_519A88(std::shared_ptr<WXSS::CSSTreeLib::Rule>& a1, std::shared_ptr<WXSS::CSSTreeLib::CSSSyntaxTree> &a2)
         {
-            // WXSS::CSSTreeLib::BlackListRule::MarkGood
             auto lit = a2->offset_24.GetLiteral();
             for (int i = 0; i < a1->offset_4_vecStr.size(); i++) {
                 std::string cur = a1->offset_4_vecStr[i];
@@ -144,17 +146,20 @@ namespace WXSS
             }
             return a2->offset_116;
         }
+
+        // WXSS::CSSTreeLib::RuleDebugRule::MarkGood
         int off_519AA0(std::shared_ptr<WXSS::CSSTreeLib::Rule>& a1, std::shared_ptr<WXSS::CSSTreeLib::CSSSyntaxTree> &a2)
         {
-            // WXSS::CSSTreeLib::RuleDebugRule::MarkGood
             std::shared_ptr<WXSS::CSSTreeLib::CSSSyntaxTree> v21;
             std::shared_ptr<WXSS::CSSTreeLib::CSSSyntaxTree> v23;
             std::shared_ptr<WXSS::CSSTreeLib::CSSSyntaxTree> v25;
+            bool hasAttrs = false;
             for (int i = 0; i < a2->offset_120.size(); i++)
             {
                 auto cur = a2->offset_120[i];
                 if (cur->offset_0 == "ATTRS")
                 {
+                    hasAttrs = true;
                     v21 = cur;
                 }
                 else if (cur->offset_0 == "{")
@@ -162,6 +167,10 @@ namespace WXSS
                     v23 = cur;
                 }
             }
+            if (!hasAttrs)
+            {
+                v21 = v23;
+            }
             auto v11 = v21->offset_168;
             auto v17 = a2->offset_120[0];
             bool la = false;
@@ -213,9 +222,10 @@ namespace WXSS
             }
             return la;
         }
+    
+        // WXSS::CSSTreeLib::ReWriteRpxRule::MarkGood
         int off_519AB8(std::shared_ptr<WXSS::CSSTreeLib::Rule>& a1, std::shared_ptr<WXSS::CSSTreeLib::CSSSyntaxTree> &a2)
         {
-            // WXSS::CSSTreeLib::ReWriteRpxRule::MarkGood
             auto lit = a2->offset_24.GetLiteral();
             std::string v9;
             if (WXML::Rewrite::RewriteRPX(lit, v9, "%%?", "?%%"))
@@ -227,14 +237,159 @@ namespace WXSS
             }
             return 0;
         }
+
+        // WXSS::CSSTreeLib::MarkSelectorRule::MarkGood
         int off_519AD0(std::shared_ptr<WXSS::CSSTreeLib::Rule>& a1, std::shared_ptr<WXSS::CSSTreeLib::CSSSyntaxTree> &a2)
         {
-            // WXSS::CSSTreeLib::MarkSelectorRule::MarkGood
+            for (int i = 0; i < a2->offset_120.size(); i++)
-            throw "not implement";
+            {
+                auto cur = a2->offset_120[i];
+                std::string v14 = cur->offset_0;
+                if (i)
+                {
+                    if (cur->offset_164 <= a2->offset_120[i - 1]->offset_168)
+                    {
+                        if (v14[0] == 'F')
+                        {
+                            if (strcmp(v14.data() + 1, "_SELECTOR"))
+                            {
+                                // LABEL_35:
+                                auto v5 = a2->offset_156;
+                                auto v6 = cur;
+                                auto v10 = v6->offset_120[0];
+                                *v5 = v10->offset_24;
+                                std::shared_ptr<std::string> str(new std::string());
+                                *str = a2->offset_148[0];
+                                a2->offset_156->offset_4 = str;
+                                return 1;
+                            }
+                            else
+                            {
+                                continue;
+                            }
+                        }
+                        auto v13 = cur->offset_120;
+                        if (v14[0] == 'S' && !strcmp(v14.data() + 1, "ELECTOR"))
+                        {
+                            if (v13.size() == 0)
+                            {
+                                continue;
+                            }
+                            for (auto i = v13.begin(); i != v13.end(); i++)
+                            {
+                                if ((*i)->offset_0[0] == '$')
+                                {
+                                    if (!strcmp((*i)->offset_0.data() + 1, "NAME"))
+                                    {
+                                        std::string lit = (*i)->offset_24.GetLiteral();
+                                        if (lit[0] == '.' || lit[0] == '@')
+                                        {
+                                            continue;
+                                        }
+                                        if (lit[0] == 'f')
+                                        {
+                                            if (!strcmp(lit.data() + 1, "orm"))
+                                            {
+                                                continue;
+                                            }
+                                        }
+                                        else if (lit[0] == 't')
+                                        {
+                                            if (!strcmp(lit.data() + 1, "o"))
+                                            {
+                                                continue;
+                                            }
+
+                                        }
+                                        if (lit[lit.length() - 1] != '%')
+                                        {
+                                            // LABEL_32
+                                            auto v5 = a2->offset_156;
+                                            auto v10 = *i;
+                                            *v5 = v10->offset_24;
+                                            std::shared_ptr<std::string> str(new std::string());
+                                            *str = a2->offset_148[0];
+                                            a2->offset_156->offset_4 = str;
+                                            return 1;
+                                        }
+                                        continue;
+                                    }
+                                    if (!strcmp((*i)->offset_0.data() + 1,"ID"))
+                                    {
+                                        auto v5 = a2->offset_156;
+                                        auto v10 = *i;
+                                        *v5 = v10->offset_24;
+                                        std::shared_ptr<std::string> str(new std::string());
+                                        *str = a2->offset_148[0];
+                                        a2->offset_156->offset_4 = str;
+                                        return 1;
+                                    }
+                                }
+                            }
+                            
+                        }
+                        break;
+                    }
+                }
+                if (v14[0] != 'F' || strcmp(v14.data() + 1, "_SELECTOR"))
+                {
+                    if (v14[0] == 'F')
+                    {
+                        if (strcmp(v14.data() + 1, "_SELECTOR"))
+                        {
+                            // LABEL_35:
+                            auto v5 = a2->offset_156;
+                            auto v6 = cur;
+                            auto v10 = v6->offset_120[0];
+                            *v5 = v10->offset_24;
+                            std::shared_ptr<std::string> str(new std::string());
+                            *str = a2->offset_148[0];
+                            a2->offset_156->offset_4 = str;
+                            return 1;
+                        }
+                        else
+                        {
+                            continue;
+                        }
+                    }
+                    break;
+                }
+                if (cur->offset_120.size() <= 1)
+                {
+                    // goto LABEL_14;
+                    auto v5 = a2->offset_156;
+                    auto v6 = cur;
+                    auto v10 = v6->offset_120[0];
+                    *v5 = v10->offset_24;
+                    std::shared_ptr<std::string> str(new std::string());
+                    *str = a2->offset_148[0];
+                    a2->offset_156->offset_4 = str;
+                    return 1;
+                }
+                auto v3 = cur->offset_120[0];
+                std::string lit = v3->offset_24.GetLiteral();
+                if (v3->offset_0[0] != '$'
+                    || strcmp(v3->offset_0.data() + 1, "NAME")
+                    || lit[0] != 'h'
+                    || strcmp(lit.data() + 1, "ost")
+                )
+                {
+                    auto v5 = a2->offset_156;
+                    auto v6 = cur;
+                    auto v10 = v6->offset_120[0];
+                    *v5 = v10->offset_24;
+                    std::shared_ptr<std::string> str(new std::string());
+                    *str = a2->offset_148[0];
+                    a2->offset_156->offset_4 = str;
+                    return 1;
+                }
+            }
+            return 1;
         }
+
+        // WXSS::CSSTreeLib::RewriteImgUrlRule::MarkGood
         int off_519AE8(std::shared_ptr<WXSS::CSSTreeLib::Rule>& a1, std::shared_ptr<WXSS::CSSTreeLib::CSSSyntaxTree> &a2)
         {
-            // WXSS::CSSTreeLib::RewriteImgUrlRule::MarkGood
             std::string lit = a2->offset_24.GetLiteral();
             std::string v10;
             auto la = a2->offset_24.offset_24;
@@ -252,13 +407,75 @@ namespace WXSS
             }
             return 0;
         }
+        // WXSS::CSSTreeLib::RewriteSelectorRule::MarkGood
         int off_519B00(std::shared_ptr<WXSS::CSSTreeLib::Rule>& a1, std::shared_ptr<WXSS::CSSTreeLib::CSSSyntaxTree> &a2)
         {
-            throw "not implement";
+            std::string v14;
+            std::string lit = a2->offset_24.GetLiteral();
+            if (lit.length())
+            {
+                for (int i = 0; i < lit.length(); i++)
+                {
+                    char ch = lit[i];
+                    if (ch == '.' && i + 1 < lit.length() && lit[i+1] - '0' > 9)
+                    {
+                        v14 += ".%%HERESUFFIX%%";
+                    }
+                    else
+                    {
+                        v14.push_back(ch);
+                    }
+                }
+                if (a2->offset_24.offset_16 != lit.length())
+                {
+                    std::shared_ptr<std::string> str(new std::string());
+                    *str = v14;
+                    a2->offset_132 = str;
+                }
+                if (!strcasecmp(v14.data(), "page"))
+                {
+                    std::shared_ptr<std::string> str(new std::string());
+                    *str = "body";
+                    a2->offset_132 = str;
+                }
+                else if(strcasecmp(v14.data(), "f"))
+                {
+                    if(strcasecmp(v14.data(), "to"))
+                    {
+                        if(strcasecmp(v14.data(), "not"))
+                        {
+                            if (v14.length())
+                            {
+                                if (isalpha(v14[0]))
+                                {
+                                    std::string v20 = v14.substr(0, 3);
+                                    if (v20 != "wx-")
+                                    {
+                                        v20 = "wx-";
+                                        v20 += v14;
+                                        
+                                        std::shared_ptr<std::string> str(new std::string());
+                                        *str = v20;
+                                        a2->offset_132 = str;
+                                    }
+                                }
+                            }
+                        }
+                        
+                    }
+                }
+                a2->offset_116 = 1;
+                return 1;
+            }
+            else
+            {
+                return 0;
+            }
+
         }
+        // WXSS::CSSTreeLib::AndRules::MarkGood
         int off_519B40(std::shared_ptr<WXSS::CSSTreeLib::Rule>& a1, std::shared_ptr<WXSS::CSSTreeLib::CSSSyntaxTree> &a2)
         {
-            // WXSS::CSSTreeLib::AndRules::MarkGood
             for (int i=0; i < a1->offset_4_vecPtr.size(); i++)
             {
                 auto cur = a1->offset_4_vecPtr[i];
@@ -273,17 +490,21 @@ namespace WXSS
             return 1;
         }
 
+        // WXSS::CSSTreeLib::TrueRule::MarkGood
         int off_519B6C(std::shared_ptr<WXSS::CSSTreeLib::Rule>& a1, std::shared_ptr<WXSS::CSSTreeLib::CSSSyntaxTree> &a2)
         {
-            // WXSS::CSSTreeLib::TrueRule::MarkGood
             a2->offset_116 = 1;
             return 1;
         }
+
+        int off_519B84_i = 0;
         /**
          * WXSS::CSSTreeLib::ChildRule::MarkGood
         */
         int off_519B84(std::shared_ptr<WXSS::CSSTreeLib::Rule>& a1, std::shared_ptr<WXSS::CSSTreeLib::CSSSyntaxTree> &a2)
         {
+            off_519B84_i++;
+            int inner_off_519B84_i = off_519B84_i;
             int v8 = 1;
             for (int j = 0; j < a2->offset_120.size(); j++)
             {
@@ -304,6 +525,7 @@ namespace WXSS
         {
             throw "not implement";
         }
+
         /**
          * 00519BB4 - WXSS::CSSTreeLib::RuleChain::MarkGood
          * 
@@ -320,9 +542,18 @@ namespace WXSS
             a2->offset_116 = ret;
             return ret;
         }
+        // WXSS::CSSTreeLib::SPNotRule::MarkGood
         int off_519BCC(std::shared_ptr<WXSS::CSSTreeLib::Rule>& a1, std::shared_ptr<WXSS::CSSTreeLib::CSSSyntaxTree> &a2)
         {
-            throw "not implement";
+            if (a2->offset_120.size() == 5)
+            {
+                std::string lit = a2->offset_120[1]->offset_24.GetLiteral();
+                if (!strcasecmp(lit.data(), "not") && !strcasecmp(a2->offset_120[3]->offset_0.data(), "SELECTOR"))
+                {
+                    a1->offset_4_ptr->offset_0(a1->offset_4_ptr, a2->offset_120[3]);
+                }
+            }
+            return 1;
         }
 
         LexicalChecker::LexicalChecker(/* args */)
@@ -368,7 +599,9 @@ namespace WXSS
                 v44->push_back(v57);
                 v44->push_back(v3);
                 std::shared_ptr<WXSS::CSSTreeLib::Rule> v59(new WXSS::CSSTreeLib::Rule());
+                v59->offset_0 = off_519B84;
                 std::shared_ptr<WXSS::CSSTreeLib::Rule> v61(new WXSS::CSSTreeLib::Rule());
+                v61->offset_0 = off_519B40;
                 // Init - 10
                 v61->offset_4_vecPtr.push_back(v59);
                 if (a3) {
@@ -417,7 +650,7 @@ namespace WXSS
                 v83->offset_0 = off_519B84;
                 std::shared_ptr<WXSS::CSSTreeLib::Rule> v85(new WXSS::CSSTreeLib::Rule());
                 v85->offset_0 = off_519BCC;
-                // v85->
+                v85->offset_4_ptr = v77;
                 v81->offset_4_vecPtr.push_back(v83);
                 v81->offset_4_vecPtr.push_back(v85);
                 
@@ -430,8 +663,8 @@ namespace WXSS
 
                 // Init - 40
                 std::shared_ptr<WXSS::CSSTreeLib::Rule> v73(new WXSS::CSSTreeLib::Rule());
-                
                 v73->offset_0 = off_519BB4;
+
                 v59->offset_4_vecPair.emplace_back("ATTRS", v73);
 
                 std::shared_ptr<WXSS::CSSTreeLib::Rule> v75(new WXSS::CSSTreeLib::Rule());
@@ -479,7 +712,7 @@ namespace WXSS
         {
             if (this->offset_0)
             {
-                this->offset_4->offset_4_vecPtr.front()->offset_0(this->offset_4, a2);
+                this->offset_4->offset_0(this->offset_4, a2);
             }
         }
             

src/wxss/css_tree_lib/rule.cpp

@@ -7,11 +7,30 @@ namespace WXSS
         namespace RuleDebugRule
         {
             void InsertOriginSelectorInfo(
-                std::shared_ptr<WXSS::CSSTreeLib::CSSSyntaxTree> &,
+                std::shared_ptr<WXSS::CSSTreeLib::CSSSyntaxTree> & a1,
-                int,
+                int a2,
-                std::shared_ptr<WXSS::CSSTreeLib::CSSSyntaxTree> &)
+                std::shared_ptr<WXSS::CSSTreeLib::CSSSyntaxTree> & a3)
             {
-                throw "not implement";
+                std::string v13, v15;
+                
+                a1->RenderCode(v13, 0);
+                a1->RenderCode(v15, 1);
+                if (v13 != v15)
+                {
+                    std::stringstream v17;
+                    v17 << ";wxcs_originclass: ";
+                    v17 << v13 << ";";
+
+                    std::shared_ptr<WXSS::CSSTreeLib::CSSSyntaxTree> lt(new WXSS::CSSTreeLib::CSSSyntaxTree());
+                    lt->offset_0 = "FAKE_ATTR";
+                    std::shared_ptr<std::string> str(new std::string());
+                    *str = v17.str();
+                    lt->offset_24.offset_4 = str;
+                    lt->offset_164 = a2;
+                    lt->offset_168 = a2 + 1;
+                    lt->offset_24.offset_0 = 3;
+                    a3->offset_120.push_back(lt);
+                }
             }
         }
     }

test/wcsc.disassembly.cpp

@@ -10279,19 +10279,19 @@ BOOL __cdecl WXML::Rewrite::RewriteRPX(int a1, unsigned int **a2, char *a3, char
   v23 = 0;
   v24 = 0;
   WXML::Rewrite::GetToken(a1, (int)&v22);
-  std::string::operator=(a2, (char *)&byte_50F1AA);
+  std::string::operator=(a2, (char *)&byte_50F1AA); // '\0'
   v17 = 1;
   for ( lpuexcpt = 1; lpuexcpt < -1227133513 * ((v23 - v22) >> 2); ++lpuexcpt )
   {
     v4 = 28 * (lpuexcpt - 1);
-    v18 = v4;
+    v18 = v4; // pre
     if ( *(_DWORD *)&v22[v4] == 1
-      && (v5 = v4 + 28, v15 = v5, !*(_DWORD *)&v22[v5])
+      && (v5 = v4 + 28, v15 = v5, !*(_DWORD *)&v22[v5]) // cur
       && !std::string::compare((int)&v22[v5 + 4], (char *)off_50F1AB) )
     {
-      std::string::basic_string(v29, Str);
+      std::string::basic_string(v29, Str); // a4
-      v16 = &v22[v15 + 4];
+      v16 = &v22[v15 + 4]; // cur
-      v19 = &v22[v18 + 4];
+      v19 = &v22[v18 + 4]; // pre
       std::string::basic_string(v25, a3);
       v6 = std::string::append(v25, (int)v19);
       std::string::basic_string(v26, v6);
@@ -45211,13 +45211,15 @@ void __stdcall WXSS::CSSTreeLib::RuleDebugRule::InsertOriginSelectorInfo(int *a1
   char v18[4]; // [esp+98h] [ebp-D0h] BYREF
   char v19[204]; // [esp+9Ch] [ebp-CCh] BYREF
 
-  v13[0] = (int)&v14;
+  v13[0] = (int)&v14; // std::string
-  v15[0] = &v16;
-  v3 = *a1;
   v13[1] = 0;
   v14 = 0;
+
+  v15[0] = &v16; // std::string
   v15[1] = 0;
   v16 = 0;
+
+  v3 = *a1;
   WXSS::CSSTreeLib::CSSSyntaxTree::RenderCode(v3, (WXSS::Token *)v13, 0);
   WXSS::CSSTreeLib::CSSSyntaxTree::RenderCode(*a1, (WXSS::Token *)v15, 1u);
   if ( !std::operator==<char>((int)v13, (int)v15) )
@@ -45236,8 +45238,9 @@ void __stdcall WXSS::CSSTreeLib::RuleDebugRule::InsertOriginSelectorInfo(int *a1
     std::__shared_ptr<std::string,(__gnu_cxx::_Lock_policy)2>::operator=((volatile signed __int32 **)v9 + 7, &v11);
     std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v12);
     v6 = v9;
-    v9[41] = a2;
+    v9[41] = a2; // v9->offset_164
     v6[42] = (unsigned int *)((char *)a2 + 1);
+    // v9->offset_168
     v6[6] = (unsigned int *)3;
     std::vector<zcc::shared_ptr<WXSS::CSSTreeLib::CSSSyntaxTree>>::push_back((void **)(*(_DWORD *)a3 + 120), &v9);
     std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v10);
@@ -46034,77 +46037,77 @@ char __stdcall WXSS::CSSTreeLib::MarkSelectorRule::MarkGood(
     v2 = *((_DWORD *)this + 30);
     if ( (unsigned int)lpuexcpt >= (*((_DWORD *)this + 31) - v2) >> 3 )
       goto LABEL_39;
-    Str = *(char **)(v2 + 8 * (_DWORD)lpuexcpt);
+    Str = *(char **)(v2 + 8 * (_DWORD)lpuexcpt); // cur
-    v14 = *(_DWORD *)Str;
+    v14 = *(_DWORD *)Str; // cur
     if ( lpuexcpt )
     {
       if ( *((_DWORD *)Str + 41) <= *(_DWORD *)(*(_DWORD *)(v2 + 8 * (_DWORD)lpuexcpt - 8) + 168) )
         break;
     }
-    if ( *(_BYTE *)v14 != 70 || strcmp((const char *)(v14 + 1), "_SELECTOR") )
+    if ( *(_BYTE *)v14 != 'F'/*70*/ || strcmp((const char *)(v14 + 1), "_SELECTOR") )
       break;
-    v3 = *((_DWORD *)Str + 30);
+    v3 = *((_DWORD *)Str + 30); // cur->offset_120
-    if ( (unsigned int)(*((_DWORD *)Str + 31) - v3) <= 8 )
+    if ( (unsigned int)(*((_DWORD *)Str + 31) - v3) <= 8 ) // size
       goto LABEL_14;
     std::__shared_ptr<WXSS::CSSTreeLib::CSSSyntaxTree,(__gnu_cxx::_Lock_policy)2>::__shared_ptr(
       &v23,
       (_DWORD *)(v3 + 8));
     Stra = v23;
-    if ( **(_BYTE **)v23 != 36
+    if ( **(_BYTE **)v23 != '$'/*36*/
       || strcmp((const char *)(*(_DWORD *)v23 + 1), "NAME")
-      || (Literal = WXSS::Token::GetLiteral((_DWORD *)Stra + 6), *Literal != 104)
+      || (Literal = WXSS::Token::GetLiteral((_DWORD *)Stra + 6), *Literal != 'h'/*104*/)
       || strcmp(Literal + 1, "ost") )
     {
       std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(v24);
 LABEL_14:
       v5 = (_DWORD *)*((_DWORD *)this + 39);
-      v6 = *(char **)(*((_DWORD *)this + 30) + 8 * (_DWORD)lpuexcpt);
+      v6 = *(char **)(*((_DWORD *)this + 30) + 8 * (_DWORD)lpuexcpt); // cur
       goto LABEL_36;
     }
     std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(v24);
 LABEL_38:
     ;
-  }
+  } // end for
-  if ( *(_BYTE *)v14 == 70 )
+  if ( *(_BYTE *)v14 == 'F'/*70*/ )
   {
     if ( strcmp((const char *)(v14 + 1), "_SELECTOR") )
       goto LABEL_35;
-    goto LABEL_38;
+    goto LABEL_38; // continue;
   }
   v13 = (_DWORD **)*((_DWORD *)Str + 30);
-  if ( *(_BYTE *)v14 == 83 && !strcmp((const char *)(v14 + 1), "ELECTOR") )
+  if ( *(_BYTE *)v14 == 'S'/*83*/ && !strcmp((const char *)(v14 + 1), "ELECTOR") )
   {
     v12 = (_DWORD **)*((_DWORD *)Str + 31);
     while ( 1 )
     {
       if ( v12 == v13 )
-        goto LABEL_38;
+        goto LABEL_38; // continue;
       v15 = *v13;
       v7 = (_BYTE *)**v13;
-      if ( *v7 == 36 )
+      if ( *v7 == '$'/*36*/ )
       {
         Strb = v7 + 1;
         if ( !strcmp(v7 + 1, "NAME") )
         {
           Strc = (char *)WXSS::Token::GetLiteral(v15 + 6);
           v8 = *Strc;
-          if ( *Strc == 46 || v8 == 64 )
+          if ( *Strc == '.'/*46*/ || v8 == '@'/*64*/ )
             goto LABEL_34;
-          if ( v8 == 102 )
+          if ( v8 == 'f'/*102*/ )
           {
             v9 = strcmp(Strc + 1, (const char *)&off_50E044);
 LABEL_30:
             if ( !v9 )
               goto LABEL_34;
           }
-          else if ( v8 == 116 )
+          else if ( v8 == 't'/*116*/ )
           {
             v9 = strcmp(Strc + 1, "o");
             goto LABEL_30;
           }
-          if ( Strc[strlen(Strc) - 1] != 37 )
+          if ( Strc[strlen(Strc) - 1] != '%'/*37*/ )
             goto LABEL_32;
-          goto LABEL_34;
+          goto LABEL_34; // continue;
         }
         if ( !strcmp(Strb, "ID") )
         {
@@ -46119,7 +46122,7 @@ LABEL_34:
     }
   }
 LABEL_35:
-  v5 = (_DWORD *)*((_DWORD *)this + 39);
+  v5 = (_DWORD *)*((_DWORD *)this + 39); // a2->offset_156
   v6 = Str;
 LABEL_36:
   v10 = (_DWORD *)**((_DWORD **)v6 + 30);
@@ -46127,11 +46130,12 @@ LABEL_37:
   WXSS::Token::operator=(v5, (int)(v10 + 6));
 LABEL_39:
   lpuexcpta = (struct _Unwind_Exception *)*((_DWORD *)this + 37);
+  // a2->offset_148
   Strd = (char *)operator new(0x18u);
   std::string::basic_string(Strd, (int)lpuexcpta);
   zcc::shared_ptr<std::string>::shared_ptr(Strd);
   std::__shared_ptr<std::string,(__gnu_cxx::_Lock_policy)2>::operator=(
-    (volatile signed __int32 **)(*((_DWORD *)this + 39) + 4),
+    (volatile signed __int32 **)(*((_DWORD *)this + 39) + 4), // a2->offset_156
     (volatile signed __int32 **)&v23);
   std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(v24);
   return 1;
@@ -46225,9 +46229,10 @@ char __stdcall WXSS::CSSTreeLib::RewriteSelectorRule::MarkGood(
   int v20; // [esp+B8h] [ebp-20h] BYREF
   volatile signed __int32 *v21; // [esp+BCh] [ebp-1Ch] BYREF
 
+  v14 = &v16; // std::string
   v15 = 0;
-  v14 = &v16;
   v16 = 0;
+
   Literal = (char *)WXSS::Token::GetLiteral((_DWORD *)this + 6);
   if ( Literal )
   {
@@ -46266,11 +46271,11 @@ char __stdcall WXSS::CSSTreeLib::RewriteSelectorRule::MarkGood(
         (volatile signed __int32 **)&v20);
       std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v21);
     }
-    else if ( __stricmp(String1[0], asc_50E043) )
+    else if ( __stricmp(String1[0], asc_50E043) ) // "f"
     {
       if ( __stricmp(String1[0], "to") )
       {
-        if ( __stricmp(String1[0], off_50DF84) )
+        if ( __stricmp(String1[0], off_50DF84) ) // { 'n', 'o', 't', '\0' }
         {
           if ( String1[1] )
           {
@@ -46671,6 +46676,7 @@ char __userpurge WXSS::CSSTreeLib::SPNotRule::MarkGood@<al>(
   if ( *((_DWORD *)this + 31) - v3 == 40 )
   {
     Literal = WXSS::Token::GetLiteral((_DWORD *)(*(_DWORD *)(v3 + 8) + 24));
+    // off_50DF84 -> { 'n', 'o', 't', '\0' }
     if ( !__stricmp(Literal, off_50DF84) && !__stricmp(**(const char ***)(*((_DWORD *)this + 30) + 24), "SELECTOR") )
       (*(void (__thiscall **)(_DWORD, _DWORD))(**(_DWORD **)(a1 + 4) + 8))(
         *(_DWORD *)(a1 + 4),