#include <bits/stdc++.h>
using namespace std;

// ========== 颜色高亮工具 ==========
#ifdef _WIN32
    #include <windows.h>
    void setColor(int color) {
        HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
        SetConsoleTextAttribute(hConsole, color);
    }
    #define COLOR_RESET 7
    #define COLOR_GREEN 10
    #define COLOR_RED 12
    #define COLOR_YELLOW 14
    #define COLOR_CYAN 11
    #define COLOR_WHITE 15
#else
    #define COLOR_RESET "\033[0m"
    #define COLOR_GREEN "\033[1;32m"
    #define COLOR_RED "\033[1;31m"
    #define COLOR_YELLOW "\033[1;33m"
    #define COLOR_CYAN "\033[1;36m"
    #define COLOR_WHITE "\033[1;37m"
    void setColor(int color) {}
#endif

void printGreen(const string& s) { setColor(COLOR_GREEN); cout << s; setColor(COLOR_RESET); }
void printRed(const string& s) { setColor(COLOR_RED); cout << s; setColor(COLOR_RESET); }
void printYellow(const string& s) { setColor(COLOR_YELLOW); cout << s; setColor(COLOR_RESET); }
void printCyan(const string& s) { setColor(COLOR_CYAN); cout << s; setColor(COLOR_RESET); }
void printWhite(const string& s) { setColor(COLOR_WHITE); cout << s; setColor(COLOR_RESET); }

// ========== 表达式解析器 ==========
class ExpressionParser {
private:
    string expr;
    size_t pos;
    map<char, double> vars;
    double parseAddSub();
    double parseMulDiv();
    double parseFactor();
    void skipSpaces() { while (pos < expr.size() && isspace(expr[pos])) pos++; }
public:
    ExpressionParser(const string& s) : expr(s), pos(0) {}
    void setVar(char name, double value) { vars[name] = value; }
    double eval();
};

double ExpressionParser::eval() { pos = 0; return parseAddSub(); }

double ExpressionParser::parseAddSub() {
    double result = parseMulDiv();
    while (true) {
        skipSpaces();
        if (pos >= expr.size()) break;
        char op = expr[pos];
        if (op == '+' || op == '-') { pos++; double val = parseMulDiv(); result += (op == '+') ? val : -val; }
        else break;
    }
    return result;
}

double ExpressionParser::parseMulDiv() {
    double result = parseFactor();
    while (true) {
        skipSpaces();
        if (pos >= expr.size()) break;
        char op = expr[pos];
        if (op == '*' || op == '/') { pos++; double val = parseFactor(); if (op == '*') result *= val; else { if (fabs(val) < 1e-12) throw runtime_error("除以零"); result /= val; } }
        else { if (pos < expr.size() && (isalpha(expr[pos]) || expr[pos] == '(')) { double val = parseFactor(); result *= val; } else break; }
    }
    return result;
}

double ExpressionParser::parseFactor() {
    skipSpaces();
    if (pos >= expr.size()) throw runtime_error("表达式意外结束");
    char ch = expr[pos];
    if (ch == '+' || ch == '-') { pos++; double val = parseFactor(); return (ch == '-') ? -val : val; }
    if (ch == '(') { pos++; double val = parseAddSub(); skipSpaces(); if (pos >= expr.size() || expr[pos] != ')') throw runtime_error("括号不匹配"); pos++; return val; }
    if (isalpha(ch)) { pos++; if (vars.find(ch) != vars.end()) return vars[ch]; throw runtime_error(string("未知变量: ") + ch); }
    if (isdigit(ch) || ch == '.') {
        string num;
        while (pos < expr.size() && (isdigit(expr[pos]) || expr[pos] == '.')) num += expr[pos++];
        if (pos < expr.size() && (expr[pos] == 'e' || expr[pos] == 'E')) {
            num += expr[pos++];
            if (pos < expr.size() && (expr[pos] == '+' || expr[pos] == '-')) num += expr[pos++];
            while (pos < expr.size() && isdigit(expr[pos])) num += expr[pos++];
        }
        try { return stod(num); } catch (...) { throw runtime_error(string("无效数字: ") + num); }
    }
    throw runtime_error(string("非法字符: ") + ch);
}

string removeSpaces(const string& s) { string r; for (char c : s) if (!isspace(c)) r += c; return r; }

// 检测是否为不等式
bool isInequality(const string& eq) {
    string s = removeSpaces(eq);
    return s.find('<') != string::npos || s.find('>') != string::npos;
}

// 提取不等号类型和位置
struct InequalityInfo {
    char sign;
    size_t pos;
    string signStr;
};

InequalityInfo getInequalitySign(const string& eq) {
    string s = removeSpaces(eq);
    InequalityInfo info;
    info.pos = string::npos;
    info.sign = '=';
    info.signStr = "";
    
    if (s.find("<=") != string::npos) {
        info.pos = s.find("<=");
        info.sign = 'l';
        info.signStr = "<=";
    } else if (s.find(">=") != string::npos) {
        info.pos = s.find(">=");
        info.sign = 'g';
        info.signStr = ">=";
    } else if (s.find('<') != string::npos) {
        info.pos = s.find('<');
        info.sign = '<';
        info.signStr = "<";
    } else if (s.find('>') != string::npos) {
        info.pos = s.find('>');
        info.sign = '>';
        info.signStr = ">";
    }
    return info;
}

// 检测方程是否为二次方程（单变量）
bool isQuadraticEquation(const string& eq) {
    string s = removeSpaces(eq);
    for (size_t i = 0; i < s.size(); i++) {
        if (s[i] == 'x' || s[i] == 'X') {
            if (i + 2 < s.size() && s[i + 1] == '^' && s[i + 2] == '2') return true;
            if (i + 2 < s.size() && s[i + 1] == '*' && (s[i + 2] == 'x' || s[i + 2] == 'X')) return true;
            if (i + 1 < s.size() && (s[i + 1] == 'x' || s[i + 1] == 'X')) return true;
        }
    }
    return false;
}

// 检测是否包含高次项（>2次）
bool hasHigherDegree(const string& eq) {
    string s = removeSpaces(eq);
    for (size_t i = 0; i < s.size(); i++) {
        if ((s[i] == 'x' || s[i] == 'X') && i + 2 < s.size() && s[i + 1] == '^') {
            if (s[i + 2] >= '3' && s[i + 2] <= '9') return true;
        }
    }
    return false;
}

// 检测是否包含变量
bool hasVariable(const string& eq) {
    string s = removeSpaces(eq);
    for (char c : s) {
        if (isalpha(c) && c != 'e' && c != 'E') return true;
    }
    return false;
}

// 提取一元二次方程的系数 ax^2 + bx + c = 0
bool parseQuadraticEquation(const string& eq, double& a, double& b, double& c, string& errorMsg) {
    errorMsg = "";
    string s = removeSpaces(eq);
    
    size_t eqPos = s.find('=');
    string left, right;
    if (eqPos == string::npos) { left = s; right = "0"; }
    else { left = s.substr(0, eqPos); right = s.substr(eqPos + 1); }
    
    if (left.empty()) { errorMsg = "方程左边不能为空"; return false; }
    
    try {
        double x0 = 0, x1 = 1, x2 = 2;
        
        ExpressionParser p0(left);
        p0.setVar('x', x0);
        double f0_left = p0.eval();
        
        ExpressionParser r0(right);
        r0.setVar('x', x0);
        double f0_right = r0.eval();
        double F0 = f0_left - f0_right;
        
        ExpressionParser p1(left);
        p1.setVar('x', x1);
        double f1_left = p1.eval();
        
        ExpressionParser r1(right);
        r1.setVar('x', x1);
        double f1_right = r1.eval();
        double F1 = f1_left - f1_right;
        
        ExpressionParser p2(left);
        p2.setVar('x', x2);
        double f2_left = p2.eval();
        
        ExpressionParser r2(right);
        r2.setVar('x', x2);
        double f2_right = r2.eval();
        double F2 = f2_left - f2_right;
        
        double c0 = F0;
        double A = (F2 - 2*F1 + F0) / 2;
        double B = F1 - F0 - A;
        
        a = A;
        b = B;
        c = c0;
        
        return true;
    } catch (const exception& e) {
        errorMsg = string("方程解析错误: ") + e.what();
        return false;
    }
}

long long gcdll(long long a, long long b) { a = abs(a); b = abs(b); while (b) { long long t = a % b; a = b; b = t; } return a; }

string doubleToFraction(double val) {
    const double EPS = 1e-9;
    if (fabs(val - round(val)) < EPS) {
        long long n = (long long)round(val);
        return to_string(n);
    }
    long long num = (long long)round(val * 1000000);
    long long den = 1000000;
    long long g = gcdll(num, den);
    num /= g; den /= g;
    if (den < 0) { num = -num; den = -den; }
    if (den == 1) return to_string(num);
    return to_string(num) + "/" + to_string(den);
}

bool isLinearEquation(const string& eq) {
    string s = removeSpaces(eq);
    
    size_t pos = s.find('^');
    if (pos != string::npos) {
        size_t p = pos + 1;
        while (p < s.size() && isspace(s[p])) p++;
        if (p < s.size() && s[p] == '1') {
            if (p + 1 < s.size() && isdigit(s[p + 1])) return false;
            return true;
        }
        return false;
    }
    
    for (size_t i = 0; i < s.size(); i++) {
        if (isalpha(s[i]) && s[i] != 'e' && s[i] != 'E') {
            if (i + 2 < s.size() && s[i + 1] == '*' && isalpha(s[i + 2]) && s[i + 2] != 'e' && s[i + 2] != 'E') {
                return false;
            }
            if (i + 1 < s.size() && isalpha(s[i + 1]) && s[i + 1] != 'e' && s[i + 1] != 'E') {
                return false;
            }
        }
    }
    return true;
}

vector<char> extractVariables(const string& eq) {
    string s = removeSpaces(eq);
    vector<char> vars;
    set<char> found;
    for (char c : s) {
        if (isalpha(c) && c != 'e' && c != 'E') {
            found.insert(c);
        }
    }
    for (char c : found) vars.push_back(c);
    return vars;
}

bool parseLinearEquation(const string& eq, double& a, double& b, double& c, string& errorMsg) {
    errorMsg = "";
    string s = removeSpaces(eq);
    
    // 如果是不等式，需要特殊处理
    if (isInequality(eq)) {
        InequalityInfo info = getInequalitySign(s);
        if (info.sign == '=') {
            errorMsg = "无法识别不等号";
            return false;
        }
        string left = s.substr(0, info.pos);
        string right = s.substr(info.pos + info.signStr.length());
        // 构造方程 left - right = 0
        string eqStr = left + "-(" + right + ")=0";
        return parseLinearEquation(eqStr, a, b, c, errorMsg);
    }
    
    size_t eqPos = s.find('=');
    string left, right;
    if (eqPos == string::npos) { left = s; right = "0"; }
    else { left = s.substr(0, eqPos); right = s.substr(eqPos + 1); }
    
    if (left.empty()) { errorMsg = "方程左边不能为空"; return false; }
    
    vector<char> vars = extractVariables(eq);
    if (vars.empty()) {
        try {
            ExpressionParser p(left);
            double f = p.eval();
            ExpressionParser rp(right);
            double rv = rp.eval();
            a = 0; b = 0; c = rv - f;
            return true;
        } catch (const exception& e) {
            errorMsg = string("常数方程解析错误: ") + e.what();
            return false;
        }
    }
    
    char var1 = vars[0];
    char var2 = (vars.size() > 1) ? vars[1] : 'y';
    
    try {
        // 使用三个采样点来拟合线性函数 F(x,y) = left - right
        // F(x,y) = A*x + B*y + C
        // 采样点: (0,0), (1,0), (0,1)
        ExpressionParser p00(left);
        p00.setVar(var1, 0.0);
        p00.setVar(var2, 0.0);
        double f00_left = p00.eval();
        
        ExpressionParser r00(right);
        r00.setVar(var1, 0.0);
        r00.setVar(var2, 0.0);
        double f00_right = r00.eval();
        double F00 = f00_left - f00_right;
        
        ExpressionParser p10(left);
        p10.setVar(var1, 1.0);
        p10.setVar(var2, 0.0);
        double f10_left = p10.eval();
        
        ExpressionParser r10(right);
        r10.setVar(var1, 1.0);
        r10.setVar(var2, 0.0);
        double f10_right = r10.eval();
        double F10 = f10_left - f10_right;
        
        ExpressionParser p01(left);
        p01.setVar(var1, 0.0);
        p01.setVar(var2, 1.0);
        double f01_left = p01.eval();
        
        ExpressionParser r01(right);
        r01.setVar(var1, 0.0);
        r01.setVar(var2, 1.0);
        double f01_right = r01.eval();
        double F01 = f01_left - f01_right;
        
        // F(0,0) = C
        // F(1,0) = A + C
        // F(0,1) = B + C
        double C = F00;
        double A = F10 - F00;
        double B = F01 - F00;
        
        a = A;
        b = B;
        c = C;  // F(x,y) = ax + by + c = 0
        
        return true;
    }
    catch (const exception& e) { 
        errorMsg = string("表达式解析错误: ") + e.what(); 
        return false; 
    }
}

// ========== 高亮显示结果 ==========
void highlightResult(const string& label, const string& value, bool isSuccess = true) {
    cout << "\n";
    printCyan("╔══════════════════════════════════════════════════════════╗\n");
    printCyan("║ ");
    printWhite("求解结果");
    printCyan("                                                      ║\n");
    printCyan("╠══════════════════════════════════════════════════════════╣\n");
    printCyan("║ ");
    cout << label;
    int padding = 56 - label.length() - value.length();
    if (padding < 0) padding = 0;
    if (isSuccess) {
        printGreen(value);
    } else {
        printRed(value);
    }
    for (int i = 0; i < padding; i++) cout << " ";
    cout << " ║\n";
    printCyan("╚══════════════════════════════════════════════════════════╝\n");
    setColor(COLOR_RESET);
}

void highlightSimple(const string& msg, bool isSuccess = true) {
    cout << "\n";
    printCyan("╔══════════════════════════════════════════════════════════╗\n");
    printCyan("║ ");
    if (isSuccess) {
        printGreen(msg);
    } else {
        printRed(msg);
    }
    int padding = 56 - msg.length();
    if (padding < 0) padding = 0;
    for (int i = 0; i < padding; i++) cout << " ";
    cout << " ║\n";
    printCyan("╚══════════════════════════════════════════════════════════╝\n");
    setColor(COLOR_RESET);
}

// ========== 求解函数 ==========

// 解一元一次不等式
void solveInequality(const string& ineq) {
    string s = removeSpaces(ineq);
    cout << "输入不等式: " << ineq << "\n";
    
    InequalityInfo info = getInequalitySign(s);
    if (info.sign == '=') {
        cout << "这不是不等式，请使用方程求解\n";
        return;
    }
    
    string left = s.substr(0, info.pos);
    string right = s.substr(info.pos + info.signStr.length());
    
    // 构造方程 left - right = 0
    string eq = left + "-(" + right + ")=0";
    
    double a, b, c; string error;
    if (!parseLinearEquation(eq, a, b, c, error)) {
        printRed("错误: " + error + "\n");
        return;
    }
    
    vector<char> vars = extractVariables(ineq);
    char var = (vars.empty()) ? 'x' : vars[0];
    
    if (vars.empty()) {
        bool isTrue;
        if (info.sign == '<') isTrue = (c < 0);
        else if (info.sign == 'l') isTrue = (c <= 0);
        else if (info.sign == '>') isTrue = (c > 0);
        else isTrue = (c >= 0);
        
        if (isTrue) {
            highlightSimple("不等式恒成立", true);
        } else {
            highlightSimple("不等式恒不成立", false);
        }
        return;
    }
    
    // 检查是否为一次不等式
    if (fabs(a) < 1e-12) {
        bool isTrue;
        if (info.sign == '<') isTrue = (c < 0);
        else if (info.sign == 'l') isTrue = (c <= 0);
        else if (info.sign == '>') isTrue = (c > 0);
        else isTrue = (c >= 0);
        
        if (isTrue) {
            highlightSimple("不等式恒成立", true);
        } else {
            highlightSimple("不等式恒不成立", false);
        }
        return;
    }
    
    // 求解 ax + c ? 0，即 ax ? -c
    double solution = -c / a;
    string solStr = doubleToFraction(solution);
    string result;
    
    // 判断不等号方向
    bool reverseSign = (a < 0);
    
    if (info.sign == '<') {
        result = string(1, var) + (reverseSign ? " > " : " < ") + solStr;
    } else if (info.sign == 'l') {
        result = string(1, var) + (reverseSign ? " ≥ " : " ≤ ") + solStr;
    } else if (info.sign == '>') {
        result = string(1, var) + (reverseSign ? " < " : " > ") + solStr;
    } else {
        result = string(1, var) + (reverseSign ? " ≤ " : " ≥ ") + solStr;
    }
    
    // 显示化简过程
    cout << "化简为: " << a << var << " + " << c << " " << info.signStr << " 0\n";
    cout << "解集: ";
    highlightResult("", result, true);
    cout << "  小数形式: " << result << "\n";
}

// 解一元二次方程
void solveQuadratic(const string& eq) {
    double a, b, c; string error;
    cout << "输入方程: " << eq << "\n";
    
    if (!parseQuadraticEquation(eq, a, b, c, error)) {
        printRed("错误: " + error + "\n");
        return;
    }
    
    if (!hasVariable(eq)) {
        if (fabs(c) < 1e-12) {
            cout << "化简为: 0 = 0 (常数方程)\n";
            highlightSimple("方程恒成立，任意 x 都是解", true);
        } else {
            cout << "化简为: 0 = " << c << " (常数方程)\n";
            highlightSimple("方程恒不成立，无解", false);
        }
        return;
    }
    
    string eqStr = "";
    if (fabs(a) > 1e-12) {
        if (fabs(a - 1) < 1e-12) eqStr += "x^2";
        else if (fabs(a + 1) < 1e-12) eqStr += "-x^2";
        else eqStr += doubleToFraction(a) + "x^2";
    }
    if (fabs(b) > 1e-12) {
        if (!eqStr.empty() && b > 0) eqStr += " + ";
        else if (!eqStr.empty() && b < 0) eqStr += " - ";
        else if (b < 0) eqStr += "-";
        if (fabs(fabs(b) - 1) > 1e-12) eqStr += doubleToFraction(fabs(b));
        eqStr += "x";
    }
    if (fabs(c) > 1e-12) {
        if (!eqStr.empty() && c > 0) eqStr += " + ";
        else if (!eqStr.empty() && c < 0) eqStr += " - ";
        else if (c < 0) eqStr += "-";
        eqStr += doubleToFraction(fabs(c));
    }
    if (eqStr.empty()) eqStr = "0";
    eqStr += " = 0";
    
    cout << "化简为: " << eqStr << "\n";
    
    const double EPS = 1e-12;
    if (fabs(a) < EPS) {
        if (fabs(b) < EPS) {
            if (fabs(c) < EPS) {
                highlightSimple("方程有无数解 (0 = 0)", true);
            } else {
                highlightSimple("方程无解 (常数项不为0)", false);
            }
        } else {
            double x = -c / b;
            string result = "x = " + doubleToFraction(x);
            highlightResult("解: ", result, true);
            cout << "  小数形式: " << setprecision(12) << x << "\n";
        }
        return;
    }
    
    double discriminant = b * b - 4 * a * c;
    
    if (fabs(discriminant) < EPS) {
        double x = -b / (2 * a);
        string result = "x = " + doubleToFraction(x) + " (重根)";
        highlightResult("解: ", result, true);
        cout << "  小数形式: " << setprecision(12) << x << "\n";
    } else if (discriminant > 0) {
        double sqrtD = sqrt(discriminant);
        double x1 = (-b + sqrtD) / (2 * a);
        double x2 = (-b - sqrtD) / (2 * a);
        string result = "x? = " + doubleToFraction(x1) + ", x? = " + doubleToFraction(x2);
        highlightResult("解: ", result, true);
        cout << "  小数形式: x? = " << setprecision(12) << x1 << ", x? = " << setprecision(12) << x2 << "\n";
    } else {
        double realPart = -b / (2 * a);
        double imagPart = sqrt(-discriminant) / (2 * a);
        string realStr = doubleToFraction(realPart);
        string imagStr = doubleToFraction(imagPart);
        if (realStr == "0") realStr = "0";
        if (imagStr == "1") imagStr = "";
        else if (imagStr == "-1") imagStr = "-";
        string result = "x? = " + realStr + " + " + imagStr + "i, x? = " + realStr + " - " + imagStr + "i";
        highlightResult("解: ", result, true);
        cout << "  小数形式: x? = " << setprecision(12) << realPart << " + " << imagPart << "i, "
             << "x? = " << realPart << " - " << imagPart << "i\n";
    }
}

// 解一元一次方程（线性）
void solveLinear(const string& eq) {
    double a, b, c; string error;
    cout << "输入方程: " << eq << "\n";
    if (!parseLinearEquation(eq, a, b, c, error)) { 
        printRed("错误: " + error + "\n"); 
        return; 
    }
    
    vector<char> vars = extractVariables(eq);
    char var = (vars.empty()) ? 'x' : vars[0];
    
    if (vars.empty()) {
        if (fabs(c) < 1e-12) {
            cout << "化简为: 0 = 0 (常数方程)\n";
            highlightSimple("方程恒成立，任意 " + string(1, var) + " 都是解", true);
        } else {
            cout << "化简为: 0 = " << c << " (常数方程)\n";
            highlightSimple("方程恒不成立，无解", false);
        }
        return;
    }
    
    if (fabs(b) > 1e-9 && vars.size() > 1) {
        cout << "警告: 此方程包含多个变量 (" << vars[0];
        if (vars.size() > 1) cout << ", " << vars[1];
        cout << ")，将忽略其他变量，仅解 " << var << "。\n";
    }
    
    cout << "化简为: " << a << var << " + " << c << " = 0\n";
    cout << "即: " << a << var << " = " << -c << "\n";
    const double EPS = 1e-12;
    if (fabs(a) < EPS) {
        if (fabs(c) < EPS) {
            highlightSimple("方程有无数解 (0 = 0)", true);
        } else {
            highlightSimple("方程无解 (0 = " + to_string(-c) + ")", false);
        }
    } else {
        double x = -c / a;
        string result = string(1, var) + " = " + doubleToFraction(x);
        highlightResult("解: ", result, true);
        cout << "  小数形式: " << setprecision(12) << x << "\n";
    }
}

// 解二元一次方程组
void solveSystem(const string& eq1, const string& eq2) {
    double a1, b1, c1, a2, b2, c2; string error;  
    vector<char> vars1 = extractVariables(eq1);
    vector<char> vars2 = extractVariables(eq2);   
    set<char> allVars;
    for (char c : vars1) allVars.insert(c);
    for (char c : vars2) allVars.insert(c);   
    vector<char> varList(allVars.begin(), allVars.end());
    if (varList.size() == 0) {
        printRed("错误: 方程中没有变量\n");
        return;
    } 
    char var1 = varList[0];
    char var2 = (varList.size() > 1) ? varList[1] : 'y';
    cout << "变量: " << var1;
    if (varList.size() > 1) cout << ", " << var2;
    cout << "\n";
    cout << "方程1: " << eq1 << "\n";
    if (!parseLinearEquation(eq1, a1, b1, c1, error)) { 
        printRed("错误 (方程1): " + error + "\n"); 
        return; 
    }
    cout << "方程2: " << eq2 << "\n";
    if (!parseLinearEquation(eq2, a2, b2, c2, error)) { 
        printRed("错误 (方程2): " + error + "\n"); 
        return; 
    }
    cout << "\n解析结果:\n";
    cout << "  方程1: " << a1 << var1 << " + " << b1 << var2 << " + " << c1 << " = 0\n";
    cout << "  方程2: " << a2 << var1 << " + " << b2 << var2 << " + " << c2 << " = 0\n";
    const double EPS = 1e-12;
    double D = a1 * b2 - a2 * b1;
    double Dx = (-c1) * b2 - (-c2) * b1;
    double Dy = a1 * (-c2) - a2 * (-c1);
    bool const1 = (fabs(a1) < EPS && fabs(b1) < EPS), const2 = (fabs(a2) < EPS && fabs(b2) < EPS);
    if (const1 && const2) {
        if (fabs(c1 - c2) < EPS) {
            highlightSimple("方程组有无数解 (两个常数方程相同)", true);
        } else {
            highlightSimple("方程组无解 (两个常数方程矛盾)", false);
        }
        return;
    }
    if (const1) {
        if (fabs(c1) > EPS) { 
            highlightSimple("方程组无解 (方程1矛盾: 0 = " + to_string(-c1) + ")", false);
            return; 
        }
        if (fabs(a2) < EPS && fabs(b2) < EPS) { 
            if (fabs(c2) < EPS) {
                highlightSimple("方程组有无数解", true);
            } else {
                highlightSimple("方程组无解", false);
            }
            return; 
        }
        if (fabs(a2) < EPS) { 
            double y = -c2 / b2; 
            string result = string(1, var1) + " 任意, " + string(1, var2) + " = " + doubleToFraction(y);
            highlightResult("解: ", result, true);
            cout << "  小数形式: " << setprecision(12) << y << "\n";
        }
        else if (fabs(b2) < EPS) { 
            double x = -c2 / a2; 
            string result = string(1, var1) + " = " + doubleToFraction(x) + ", " + string(1, var2) + " 任意";
            highlightResult("解: ", result, true);
            cout << "  小数形式: " << setprecision(12) << x << "\n";
        }
        else {
            string msg = "方程组有无数解 (一个方程约束)\n  关系: " + to_string(a2) + string(1, var1) + " + " + to_string(b2) + string(1, var2) + " + " + to_string(c2) + " = 0";
            highlightSimple(msg, true);
        }
        return;
    }
    if (const2) {
        if (fabs(c2) > EPS) { 
            highlightSimple("方程组无解 (方程2矛盾: 0 = " + to_string(-c2) + ")", false);
            return; 
        }
        if (fabs(a1) < EPS && fabs(b1) < EPS) { 
            if (fabs(c1) < EPS) {
                highlightSimple("方程组有无数解", true);
            } else {
                highlightSimple("方程组无解", false);
            }
            return; 
        }
        if (fabs(a1) < EPS) { 
            double y = -c1 / b1; 
            string result = string(1, var1) + " 任意, " + string(1, var2) + " = " + doubleToFraction(y);
            highlightResult("解: ", result, true);
            cout << "  小数形式: " << setprecision(12) << y << "\n";
        }
        else if (fabs(b1) < EPS) { 
            double x = -c1 / a1; 
            string result = string(1, var1) + " = " + doubleToFraction(x) + ", " + string(1, var2) + " 任意";
            highlightResult("解: ", result, true);
            cout << "  小数形式: " << setprecision(12) << x << "\n";
        }
        else {
            string msg = "方程组有无数解 (一个方程约束)\n  关系: " + to_string(a1) + string(1, var1) + " + " + to_string(b1) + string(1, var2) + " + " + to_string(c1) + " = 0";
            highlightSimple(msg, true);
        }
        return;
    }
    if (fabs(D) < EPS) {
        if (fabs(Dx) < EPS && fabs(Dy) < EPS) {
            bool proportional = true;
            if (fabs(a1) > EPS && fabs(a2) > EPS) { 
                double ratio = a1 / a2; 
                if (fabs(b1 - b2 * ratio) > EPS * 100 || fabs(c1 - c2 * ratio) > EPS * 100) proportional = false; 
            }
            else if (fabs(b1) > EPS && fabs(b2) > EPS) { 
                double ratio = b1 / b2; 
                if (fabs(a1 - a2 * ratio) > EPS * 100 || fabs(c1 - c2 * ratio) > EPS * 100) proportional = false; 
            }
            else proportional = true;
            if (proportional) {
                string msg = "方程组有无数解 (两个方程成比例)\n  关系: " + to_string(a1) + string(1, var1) + " + " + to_string(b1) + string(1, var2) + " + " + to_string(c1) + " = 0";
                highlightSimple(msg, true);
            } else {
                highlightSimple("方程组有无数解 (方程线性相关)", true);
            }
        } else {
            highlightSimple("方程组无解 (矛盾)", false);
        }
    } else {
        double x = Dx / D, y = Dy / D;
        string result = string(1, var1) + " = " + doubleToFraction(x) + ", " + 
                       string(1, var2) + " = " + doubleToFraction(y);
        highlightResult("解: ", result, true);
        cout << "  小数形式: " << var1 << " = " << setprecision(12) << x << ", " << var2 << " = " << setprecision(12) << y << "\n";
        
        double v1 = a1 * x + b1 * y + c1, v2 = a2 * x + b2 * y + c2;
        cout << "验证: " << v1 << " = 0, " << v2 << " = 0\n";
    }
}
// 自动检测方程类型并求解
void solveEquation(const string& eq) {
    string s = removeSpaces(eq);
    
    // 检查是否为不等式
    if (isInequality(eq)) {
        solveInequality(eq);
        return;
    }
    // 检查是否包含高次项
    if (hasHigherDegree(s)) {
        printRed("错误: 此方程包含超过2次的高次项，本程序暂不支持\n");
        return;
    }
    // 检查是否为一元二次方程
    if (isQuadraticEquation(eq)) {
        vector<char> vars = extractVariables(eq);
        if (vars.size() == 1 && (vars[0] == 'x' || vars[0] == 'X')) {
            solveQuadratic(eq);
            return;
        } else {
            printRed("错误: 一元二次方程只能包含一个变量 x\n");
            return;
        }
    }
    // 检查是否为线性方程
    if (isLinearEquation(s)) {
        vector<char> vars = extractVariables(eq);
        if (vars.size() <= 1) {
            solveLinear(eq);
        } else {
            printRed("错误: 检测到多个变量，请使用二元方程组模式(选项2)\n");
        }
        return;
    }
    printRed("错误: 无法识别的方程类型\n");
}
int main() {
    int choice; string eq1, eq2;
    #ifdef _WIN32
        system("color 0F");
    #endif
    cout << "==============================================\n";
    printCyan("    方程/不等式求解器\n");
    cout << "==============================================\n";
    cout << "支持格式:\n";
    cout << "  - 一元一次: 2x+3=7, 3*x-5=10, -x+4=2x+1\n";
    cout << "  - 一元二次: x^2-5x+6=0, x*x-5x+6=0, 2x^2+3x-5=0\n";
    cout << "  - 二元一次: 2a+3b=5, m-2n=1, 3x-4y+2=0\n";
    cout << "  - 一元一次不等式: 2x+3<7, 3x-5>=10, -x+4>2x+1\n";
    cout << "  - 常数方程: 7*8=56, 2+3=5 (恒等式/矛盾式)\n";
    cout << "  - 右边有变量: 78+91=x, 2x+3=5x-7\n";
    cout << "  - 隐式乘法: 2x, 3(x+1) (仅系数乘变量)\n";
    cout << "  - 负数: -x+2=3, 2a-3b=-5\n";
    cout << "==============================================\n";
    while (true) {
        cout << "\n请选择:\n";
        cout << "  1. 解一元方程/不等式 (自动识别)\n";
        cout << "  2. 解二元一次方程组\n";
        cout << "  3. 退出\n";
        cout << "选择 (1/2/3): ";
        cin >> choice;
        if (cin.fail()) { cin.clear(); cin.ignore(10000, '\n'); cout << "输入无效，请输入数字 1, 2 或 3。\n"; continue; }
        cin.ignore(10000, '\n');
        switch (choice) {
            case 1: 
                cout << "请输入一元方程或不等式: "; 
                getline(cin, eq1); 
                if (eq1.empty()) cout << "输入不能为空。\n"; 
                else solveEquation(eq1); 
                break;
            case 2: 
                cout << "请输入第一个方程: "; 
                getline(cin, eq1); 
                if (eq1.empty()) { cout << "方程不能为空。\n"; break; }
                cout << "请输入第二个方程: "; 
                getline(cin, eq2); 
                if (eq2.empty()) { cout << "方程不能为空。\n"; break; } 
                solveSystem(eq1, eq2); 
                break;
            case 3: 
                cout << "感谢使用，再见！\n"; 
                return 0;
            default: 
                cout << "无效选择，请输入 1, 2 或 3。\n";
        }
    }
    return 0;
}