Update app.py

app.py

@@ -14,306 +14,389 @@ app.logger = logging.getLogger("CodeSearchAPI")
 # 预定义代码片段
 CODE_SNIPPETS = [
 
-"void printText(const std::string& text) { std::cout << text; }",  
-"int sum(int a, int b) { return a + b; }",  
-"int generateRandomNumber() { return rand(); }",  
-"bool isEven(int num) { return num % 2 == 0; }",  
-"size_t getStringLength(const std::string& str) { return str.length(); }",  
-"std::string getCurrentDate() { time_t now = time(0); return ctime(&now); }",  
-"bool fileExists(const std::string& filename) { std::ifstream file(filename); return file.good(); }",  
-"std::string readFileContent(const std::string& filename) { std::ifstream file(filename); std::string content((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>()); return content; }",  
-"void writeToFile(const std::string& filename, const std::string& content) { std::ofstream file(filename); file << content; }",  
-"std::string getCurrentTime() { time_t now = time(0); return ctime(&now); }",  
-"std::string toUpper(const std::string& str) { std::string result = str; std::transform(result.begin(), result.end(), result.begin(), ::toupper); return result; }",  
-"std::string toLower(const std::string& str) { std::string result = str; std::transform(result.begin(), result.end(), result.begin(), ::tolower); return result; }",  
-"std::string reverseString(const std::string& str) { std::string result = str; std::reverse(result.begin(), result.end()); return result; }",  
-"size_t countListElements(const std::vector<int>& list) { return list.size(); }",  
-"int findMax(const std::vector<int>& list) { return *std::max_element(list.begin(), list.end()); }",  
-"int findMin(const std::vector<int>& list) { return *std::min_element(list.begin(), list.end()); }",  
-"void sortList(std::vector<int>& list) { std::sort(list.begin(), list.end()); }",  
-"std::vector<int> mergeLists(const std::vector<int>& list1, const std::vector<int>& list2) { std::vector<int> result = list1; result.insert(result.end(), list2.begin(), list2.end()); return result; }",  
-"void removeElementFromList(std::vector<int>& list, int element) { list.erase(std::remove(list.begin(), list.end(), element), list.end()); }",  
-"bool isListEmpty(const std::vector<int>& list) { return list.empty(); }",  
-"size_t countCharInString(const std::string& str, char ch) { return std::count(str.begin(), str.end(), ch); }",  
-"bool containsSubstring(const std::string& str, const std::string& substr) { return str.find(substr) != std::string::npos; }",  
-"std::string numToString(int num) { return std::to_string(num); }",  
-"int stringToNum(const std::string& str) { return std::stoi(str); }",  
-"bool isNumeric(const std::string& str) { return !str.empty() && std::all_of(str.begin(), str.end(), ::isdigit); }",  
-"int getIndexInList(const std::vector<int>& list, int element) { auto it = std::find(list.begin(), list.end(), element); return it != list.end() ? std::distance(list.begin(), it) : -1; }",  
-"void clearList(std::vector<int>& list) { list.clear(); }",  
-"void reverseList(std::vector<int>& list) { std::reverse(list.begin(), list.end()); }",  
-"std::vector<int> removeDuplicatesFromList(const std::vector<int>& list) { std::set<int> s(list.begin(), list.end()); return std::vector<int>(s.begin(), s.end()); }",  
-"bool isInList(const std::vector<int>& list, int value) { return std::find(list.begin(), list.end(), value) != list.end(); }",  
-"std::map<std::string, int> createDict() { return {}; }",  
-"void addToDict(std::map<std::string, int>& dict, const std::string& key, int value) { dict[key] = value; }",  
-"void removeKeyFromDict(std::map<std::string, int>& dict, const std::string& key) { dict.erase(key); }",  
-"std::vector<std::string> getDictKeys(const std::map<std::string, int>& dict) { std::vector<std::string> keys; for (const auto& pair : dict) keys.push_back(pair.first); return keys; }",  
-"std::vector<int> getDictValues(const std::map<std::string, int>& dict) { std::vector<int> values; for (const auto& pair : dict) values.push_back(pair.second); return values; }",  
-"std::map<std::string, int> mergeDicts(const std::map<std::string, int>& dict1, const std::map<std::string, int>& dict2) { std::map<std::string, int> result = dict1; result.insert(dict2.begin(), dict2.end()); return result; }",  
-"bool isDictEmpty(const std::map<std::string, int>& dict) { return dict.empty(); }",  
-"int getValueFromDict(const std::map<std::string, int>& dict, const std::string& key) { return dict.at(key); }",  
-"bool keyExistsInDict(const std::map<std::string, int>& dict, const std::string& key) { return dict.find(key) != dict.end(); }",  
-"void clearDict(std::map<std::string, int>& dict) { dict.clear(); }",  
-"size_t countFileLines(const std::string& filename) { std::ifstream file(filename); return std::count(std::istreambuf_iterator<char>(file), std::istreambuf_iterator<char>(), '\n'); }",  
-"void writeListToFile(const std::string& filename, const std::vector<int>& list) { std::ofstream file(filename); for (int elem : list) file << elem << std::endl; }",  
-"std::vector<int> readListFromFile(const std::string& filename) { std::ifstream file(filename); std::vector<int> list; int elem; while (file >> elem) list.push_back(elem); return list; }",  
-"size_t countWordsInFile(const std::string& filename) { std::ifstream file(filename); std::string word; size_t count = 0; while (file >> word) count++; return count; }",  
-"bool isLeapYear(int year) { return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0); }",  
-"std::string formatTime(const std::string& format) { char buffer[80]; time_t now = time(0); strftime(buffer, sizeof(buffer), format.c_str(), localtime(&now)); return buffer; }",  
-"int daysBetweenDates(const std::string& date1, const std::string& date2) { struct tm tm1 = {}, tm2 = {}; strptime(date1.c_str(), \"%Y-%m-%d\", &tm1); strptime(date2.c_str(), \"%Y-%m-%d\", &tm2); time_t time1 = mktime(&tm1), time2 = mktime(&tm2); return difftime(time2, time1) / (60 * 60 * 24); }",  
-"std::string getCurrentWorkingDirectory() { char buffer[FILENAME_MAX]; getcwd(buffer, FILENAME_MAX); return buffer; }",  
-"std::vector<std::string> listFilesInDirectory(const std::string& path) { std::vector<std::string> files; for (const auto& entry : std::filesystem::directory_iterator(path)) files.push_back(entry.path().filename().string()); return files; }",  
-"void createDirectory(const std::string& path) { std::filesystem::create_directory(path); }",  
-"void deleteDirectory(const std::string& path) { std::filesystem::remove_all(path); }",  
-"bool isFile(const std::string& path) { return std::filesystem::is_regular_file(path); }",  
-"bool isDirectory(const std::string& path) { return std::filesystem::is_directory(path); }",  
-"size_t getFileSize(const std::string& filename) { return std::filesystem::file_size(filename); }",  
-"void renameFile(const std::string& oldName, const std::string& newName) { std::filesystem::rename(oldName, newName); }",  
-"void copyFile(const std::string& src, const std::string& dest) { std::filesystem::copy(src, dest); }",  
-"void moveFile(const std::string& src, const std::string& dest) { std::filesystem::rename(src, dest); }",  
-"void deleteFile(const std::string& filename) { std::filesystem::remove(filename); }",  
-"std::string getEnvVariable(const std::string& var) { const char* value = std::getenv(var.c_str()); return value ? value : \"\"; }",  
-"void setEnvVariable(const std::string& var, const std::string& value) { setenv(var.c_str(), value.c_str(), 1); }",  
-"void openWebLink(const std::string& url) { std::string command = \"xdg-open \" + url; system(command.c_str()); }",  
-"std::string sendGetRequest(const std::string& url) { std::string command = \"curl -s \" + url; std::string result; FILE* pipe = popen(command.c_str(), \"r\"); char buffer[128]; while (fgets(buffer, sizeof(buffer), pipe) != NULL) result += buffer; pclose(pipe); return result; }",  
-"nlohmann::json parseJson(const std::string& jsonStr) { return nlohmann::json::parse(jsonStr); }",  
-"void writeJsonToFile(const std::string& filename, const nlohmann::json& jsonData) { std::ofstream file(filename); file << jsonData.dump(4); }",  
-"nlohmann::json readJsonFromFile(const std::string& filename) { std::ifstream file(filename); return nlohmann::json::parse(file); }",  
-"std::string listToString(const std::vector<std::string>& list) { std::string result; for (const auto& elem : list) result += elem; return result; }",  
-"std::vector<std::string> stringToList(const std::string& str) { std::vector<std::string> list; std::stringstream ss(str); std::string item; while (std::getline(ss, item, ' ')) list.push_back(item); return list; }",  
-"std::string joinListWithComma(const std::vector<std::string>& list) { std::string result; for (size_t i = 0; i < list.size(); i++) { result += list[i]; if (i != list.size() - 1) result += \",\"; } return result; }",  
-"std::string joinListWithNewline(const std::vector<std::string>& list) { std::string result; for (const auto& elem : list) result += elem + \"\\n\"; return result; }",  
-"std::vector<std::string> splitStringBySpace(const std::string& str) { std::vector<std::string> tokens; std::stringstream ss(str); std::string token; while (ss >> token) tokens.push_back(token); return tokens; }",  
-"std::vector<std::string> splitStringByDelimiter(const std::string& str, char delimiter) { std::vector<std::string> tokens; std::stringstream ss(str); std::string token; while (std::getline(ss, token, delimiter)) tokens.push_back(token); return tokens; }",  
-"std::vector<char> splitStringToChars(const std::string& str) { return std::vector<char>(str.begin(), str.end()); }",  
-"std::string replaceInString(const std::string& str, const std::string& oldStr, const std::string& newStr) { std::string result = str; size_t pos = 0; while ((pos = result.find(oldStr, pos)) != std::string::npos) { result.replace(pos, oldStr.length(), newStr); pos += newStr.length(); } return result; }",  
-"std::string removeSpaces(const std::string& str) { std::string result = str; result.erase(std::remove(result.begin(), result.end(), ' '), result.end()); return result; }",  
-"std::string removePunctuation(const std::string& str) { std::string result = str; result.erase(std::remove_if(result.begin(), result.end(), ::ispunct), result.end()); return result; }",  
-"bool isStringEmpty(const std::string& str) { return str.empty(); }",  
-"bool isPalindrome(const std::string& str) { std::string reversed = str; std::reverse(reversed.begin(), reversed.end()); return str == reversed; }",  
-"void writeToCsv(const std::string& filename, const std::vector<std::vector<std::string>>& data) { std::ofstream file(filename); for (const auto& row : data) { for (size_t i = 0; i < row.size(); i++) { file << row[i]; if (i != row.size() - 1) file << \",\"; } file << \"\\n\"; } }",  
-"std::vector<std::vector<std::string>> readFromCsv(const std::string& filename) { std::vector<std::vector<std::string>> data; std::ifstream file(filename); std::string line; while (std::getline(file, line)) { std::vector<std::string> row; std::stringstream ss(line); std::string cell; while (std::getline(ss, cell, ',')) row.push_back(cell); data.push_back(row); } return data; }",  
-"size_t countCsvLines(const std::string& filename) { std::ifstream file(filename); return std::count(std::istreambuf_iterator<char>(file), std::istreambuf_iterator<char>(), '\n'); }",  
-"void shuffleList(std::vector<int>& list) { std::shuffle(list.begin(), list.end(), std::default_random_engine(std::chrono::system_clock::now().time_since_epoch().count())); }",  
-"int pickRandomElement(const std::vector<int>& list) { return list[rand() % list.size()]; }",  
-"std::vector<int> pickRandomElements(const std::vector<int>& list, size_t count) { std::vector<int> result = list; std::shuffle(result.begin(), result.end(), std::default_random_engine(std::chrono::system_clock::now().time_since_epoch().count())); result.resize(count); return result; }",  
-"int rollDice() { return rand() % 6 + 1; }",  
-"std::string flipCoin() { return rand() % 2 == 0 ? \"Heads\" : \"Tails\"; }",  
-"std::string generateRandomPassword(size_t length) { const std::string chars = \"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\"; std::string password; for (size_t i = 0; i < length; i++) password += chars[rand() % chars.length()]; return password; }",  
-"std::string generateRandomColor() { const std::string hexChars = \"0123456789ABCDEF\"; std::string color = \"#\"; for (int i = 0; i < 6; i++) color += hexChars[rand() % hexChars.length()]; return color; }",  
-"std::string generateUniqueId() { return std::to_string(std::chrono::system_clock::now().time_since_epoch().count()); }",  
-"class MyClass {};",  
-"MyClass createClassInstance() { return MyClass(); }",  
-"class MyClass { public: void myMethod() {} };",  
-"class MyClass { public: int myProperty; };",  
-"class ChildClass : public MyClass {};",  
-"class ChildClass : public MyClass { public: void myMethod() override {} };",  
-"class MyClass { public: static void myClassMethod() {} };",  
-"class MyClass { public: static void myStaticMethod() {} };",  
-"template <typename T> bool isType(const T& obj, const std::type_info& type) { return typeid(obj) == type; }",  
-"template <typename T> auto getProperty(const T& obj, const std::string& prop) { return obj.*prop; }",  
-"template <typename T> void setProperty(T& obj, const std::string& prop, const auto& value) { obj.*prop = value; }",  
-"template <typename T> void deleteProperty(T& obj, const std::string& prop) { obj.*prop = nullptr; }",
-"void handleException() { try { throw std::runtime_error(\"Error occurred\"); } catch (const std::exception& e) { std::cerr << e.what() << std::endl; }}",
-"void throwCustomException() { throw std::runtime_error(\"Custom error\"); }",
-"void getExceptionInfo() { try { throw std::runtime_error(\"Error occurred\"); } catch (const std::exception& e) { std::cerr << e.what() << std::endl; }}",
-"void logError(const std::string& message) { std::cerr << \"Error: \" << message << std::endl; }",
-"class Timer { public: Timer() : start(std::chrono::high_resolution_clock::now()) {} double elapsed() { return std::chrono::duration<double>(std::chrono::high_resolution_clock::now() - start).count(); } private: std::chrono::time_point<std::chrono::high_resolution_clock> start; };",
-"double getRuntime() { static Timer timer; return timer.elapsed(); }",
-"void printProgressBar(int progress, int total) { float percentage = static_cast<float>(progress) / total; int barWidth = 50; std::cout << \"[\"; int pos = barWidth * percentage; for (int i = 0; i < barWidth; ++i) { if (i < pos) std::cout << \"=\"; else if (i == pos) std::cout << \">\"; else std::cout << \" \"; } std::cout << \"] \" << int(percentage * 100.0) << \" %\\r\"; std::cout.flush(); }",
-"void delay(int milliseconds) { std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds)); }",
-"auto lambda = [](int x) { return x * x; };",
-"std::vector<int> mapFunc(const std::vector<int>& vec, std::function<int(int)> func) { std::vector<int> result; for (int x : vec) result.push_back(func(x)); return result; }",
-"std::vector<int> filterFunc(const std::vector<int>& vec, std::function<bool(int)> func) { std::vector<int> result; for (int x : vec) if (func(x)) result.push_back(x); return result; }",
-"int reduceFunc(const std::vector<int>& vec, std::function<int(int, int)> func, int init) { int result = init; for (int x : vec) result = func(result, x); return result; }",
-"std::vector<int> listComprehension(const std::vector<int>& vec) { std::vector<int> result; for (int x : vec) if (x % 2 == 0) result.push_back(x); return result; }",
-"std::map<int, int> dictComprehension(const std::vector<int>& vec) { std::map<int, int> result; for (int x : vec) result[x] = x * x; return result; }",
-"std::set<int> setComprehension(const std::vector<int>& vec) { std::set<int> result; for (int x : vec) if (x % 2 == 0) result.insert(x); return result; }",
-"std::set<int> setIntersection(const std::set<int>& set1, const std::set<int>& set2) { std::set<int> result; std::set_intersection(set1.begin(), set1.end(), set2.begin(), set2.end(), std::inserter(result, result.begin())); return result; }",
-"std::set<int> setUnion(const std::set<int>& set1, const std::set<int>& set2) { std::set<int> result; std::set_union(set1.begin(), set1.end(), set2.begin(), set2.end(), std::inserter(result, result.begin())); return result; }",
-"std::set<int> setDifference(const std::set<int>& set1, const std::set<int>& set2) { std::set<int> result; std::set_difference(set1.begin(), set1.end(), set2.begin(), set2.end(), std::inserter(result, result.begin())); return result; }",
-"std::vector<int> removeNullValues(const std::vector<int>& vec) { std::vector<int> result; for (int x : vec) if (x != 0) result.push_back(x); return result; }",
-"bool tryOpenFile(const std::string& filename) { std::ifstream file(filename); return file.is_open(); }",
-"template <typename T> bool checkType(const T& var) { return typeid(var).name() == typeid(T).name(); }",
-"bool strToBool(const std::string& str) { return str == \"true\" || str == \"1\"; }",
-"void ifCondition(int x) { if (x > 0) std::cout << \"Positive\" << std::endl; }",
-"void whileLoop(int x) { while (x-- > 0) std::cout << x << std::endl; }",
-"void forLoopList(const std::vector<int>& vec) { for (int x : vec) std::cout << x << std::endl; }",
-"void forLoopDict(const std::map<int, int>& dict) { for (const auto& pair : dict) std::cout << pair.first << \": \" << pair.second << std::endl; }",
-"void forLoopString(const std::string& str) { for (char c : str) std::cout << c << std::endl; }",
-"void breakLoop() { for (int i = 0; i < 10; ++i) { if (i == 5) break; std::cout << i << std::endl; } }",
-"void continueLoop() { for (int i = 0; i < 10; ++i) { if (i == 5) continue; std::cout << i << std::endl; } }",
-"void defineFunction() { std::cout << \"Function defined\" << std::endl; }",
-"void functionWithDefault(int x = 10) { std::cout << x << std::endl; }",
-"std::pair<int, int> returnMultipleValues() { return {1, 2}; }",
-"template <typename... Args> void variadicFunction(Args... args) { (std::cout << ... << args) << std::endl; }",
-"void keywordArguments(int x, int y) { std::cout << x << \", \" << y << std::endl; }",
-"void logFunctionTime(std::function<void()> func) { Timer timer; func(); std::cout << \"Time elapsed: \" << timer.elapsed() << \"s\" << std::endl; }",
-"template <typename Func> void decorator(Func func) { std::cout << \"Before\" << std::endl; func(); std::cout << \"After\" << std::endl; }",
-"template <typename Func> auto cacheFunction(Func func) { static std::map<std::string, decltype(func())> cache; return [func](const std::string& key) { if (cache.find(key) == cache.end()) cache[key] = func(); return cache[key]; }; }",
-"class Generator { public: Generator() : value(0) {} int next() { return value++; } private: int value; };",
-"int yieldValue() { static int value = 0; return value++; }",
-"int getNextValue() { static int value = 0; return value++; }",
-"class Iterator { public: Iterator(const std::vector<int>& vec) : vec(vec), index(0) {} int next() { return vec[index++]; } bool hasNext() { return index < vec.size(); } private: std::vector<int> vec; int index; };",
-"void manualIterate(const std::vector<int>& vec) { Iterator it(vec); while (it.hasNext()) std::cout << it.next() << std::endl; }",
-"void enumerateList(const std::vector<int>& vec) { for (int i = 0; i < vec.size(); ++i) std::cout << i << \": \" << vec[i] << std::endl; }",
-"std::vector<std::pair<int, int>> zipLists(const std::vector<int>& vec1, const std::vector<int>& vec2) { std::vector<std::pair<int, int>> result; for (int i = 0; i < std::min(vec1.size(), vec2.size()); ++i) result.emplace_back(vec1[i], vec2[i]); return result; }",
-"std::map<int, int> listsToDict(const std::vector<int>& keys, const std::vector<int>& values) { std::map<int, int> result; for (int i = 0; i < std::min(keys.size(), values.size()); ++i) result[keys[i]] = values[i]; return result; }",
-"bool listsEqual(const std::vector<int>& vec1, const std::vector<int>& vec2) { return vec1 == vec2; }",
-"bool dictsEqual(const std::map<int, int>& dict1, const std::map<int, int>& dict2) { return dict1 == dict2; }",
-"bool setsEqual(const std::set<int>& set1, const std::set<int>& set2) { return set1 == set2; }",
-"std::vector<int> removeDuplicatesList(const std::vector<int>& vec) { std::set<int> s(vec.begin(), vec.end()); return std::vector<int>(s.begin(), s.end()); }",
-"void clearSet(std::set<int>& s) { s.clear(); }",
-"bool isSetEmpty(const std::set<int>& s) { return s.empty(); }",
-"void addToSet(std::set<int>& s, int value) { s.insert(value); }",
-"void removeFromSet(std::set<int>& s, int value) { s.erase(value); }",
-"bool setContains(const std::set<int>& s, int value) { return s.find(value) != s.end(); }",
-"int setSize(const std::set<int>& s) { return s.size(); }",
-"bool setsIntersect(const std::set<int>& set1, const std::set<int>& set2) { return !setIntersection(set1, set2).empty(); }",
-"bool isSubset(const std::vector<int>& vec1, const std::vector<int>& vec2) { std::set<int> s1(vec1.begin(), vec1.end()), s2(vec2.begin(), vec2.end()); return std::includes(s2.begin(), s2.end(), s1.begin(), s1.end()); }",
-"bool isSubstring(const std::string& str, const std::string& substr) { return str.find(substr) != std::string::npos; }",
-"char firstChar(const std::string& str) { return str.empty() ? '\\0' : str[0]; }",
-"char lastChar(const std::string& str) { return str.empty() ? '\\0' : str.back(); }",
-"bool isTextFile(const std::string& filename) { std::ifstream file(filename); char c; while (file.get(c)) if (!std::isprint(c) && !std::isspace(c)) return false; return true; }",
-"bool isImageFile(const std::string& filename) { std::string ext = filename.substr(filename.find_last_of(\".\") + 1); return ext == \"jpg\" || ext == \"png\" || ext == \"gif\"; }",
-"double roundNumber(double num) { return std::round(num); }",
-"double ceilNumber(double num) { return std::ceil(num); }",
-"double floorNumber(double num) { return std::floor(num); }",
-"std::string formatDecimal(double num, int precision) { std::ostringstream oss; oss << std::fixed << std::setprecision(precision) << num; return oss.str(); }",
-"std::string generateRandomString(int length) { static const char alphanum[] = \"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\"; std::string result; for (int i = 0; i < length; ++i) result += alphanum[rand() % (sizeof(alphanum) - 1)]; return result; }",
-"bool pathExists(const std::string& path) { std::ifstream file(path); return file.good(); }",
-"void traverseDirectory(const std::string& path) { for (const auto& entry : std::filesystem::directory_iterator(path)) std::cout << entry.path() << std::endl; }",
-"std::string getFileExtension(const std::string& filename) { return filename.substr(filename.find_last_of(\".\") + 1); }",
-"std::string getFileName(const std::string& path) { return path.substr(path.find_last_of(\"/\\\") + 1); }",
-"std::string getFullPath(const std::string& path) { return std::filesystem::absolute(path).string(); }",
-"std::string getPythonVersion() { return \"C++ does not have Python version\"; }",
-"std::string getSystemPlatform() { #ifdef _WIN32 return \"Windows\"; #elif __linux__ return \"Linux\"; #elif __APPLE__ return \"macOS\"; #else return \"Unknown\"; #endif }",
-"int getCPUCores() { return std::thread::hardware_concurrency(); }",
-"size_t getMemorySize() { return sysconf(_SC_PHYS_PAGES) * sysconf(_SC_PAGE_SIZE); }",
-"std::string getDiskUsage() { struct statvfs stats; if (statvfs(\"/\", &stats) == 0) return std::to_string(stats.f_bsize * stats.f_bfree); return \"Unknown\"; }",
-"std::string getIPAddress() { struct ifaddrs* ifAddrStruct = nullptr; getifaddrs(&ifAddrStruct); std::string result; for (struct ifaddrs* ifa = ifAddrStruct; ifa != nullptr; ifa = ifa->ifa_next) { if (ifa->ifa_addr && ifa->ifa_addr->sa_family == AF_INET) { result = inet_ntoa(((struct sockaddr_in*)ifa->ifa_addr)->sin_addr); break; } } if (ifAddrStruct) freeifaddrs(ifAddrStruct); return result; }",
-"bool isConnectedToInternet() { return system(\"ping -c 1 google.com\") == 0; }",
-"void downloadFile(const std::string& url, const std::string& filename) { std::string command = \"curl -o \" + filename + \" \" + url; system(command.c_str()); }",
-"void uploadFile(const std::string& filename) { std::cout << \"File uploaded: \" << filename << std::endl; }",
-"void sendPostRequest(const std::string& url, const std::string& data) { std::string command = \"curl -X POST -d '\" + data + \"' \" + url; system(command.c_str()); }",
-"void sendRequestWithParams(const std::string& url, const std::map<std::string, std::string>& params) { std::string command = \"curl -X GET \"; for (const auto& pair : params) command += \"-d \" + pair.first + \"=\" + pair.second + \" \"; command += url; system(command.c_str()); }",
-"void setRequestHeader(const std::string& url, const std::map<std::string, std::string>& headers) { std::string command = \"curl -X GET \"; for (const auto& pair : headers) command += \"-H '\" + pair.first + \": \" + pair.second + \"' \"; command += url; system(command.c_str()); }",
-"void parseHTML(const std::string& html) { std::regex pattern(\"<[^>]*>\"); std::smatch matches; std::string result = std::regex_replace(html, pattern, \"\"); std::cout << result << std::endl; }",
-"std::string extractTitle(const std::string& html) { std::regex pattern(\"<title>(.*?)</title>\"); std::smatch matches; if (std::regex_search(html, matches, pattern)) return matches[1]; return \"\"; }",
-"std::vector<std::string> extractLinks(const std::string& html) { std::regex pattern(\"<a href=\\\"(.*?)\\\".*?>\", std::regex_constants::icase); std::smatch matches; std::vector<std::string> result; for (std::sregex_iterator it(html.begin(), html.end(), pattern), end; it != end; ++it) result.push_back((*it)[1]); return result; }",
-"void downloadImages(const std::string& html, const std::string& path) { std::regex pattern(\"<img[^>]+src=\\\"(.*?)\\\"[^>]*>\", std::regex_constants::icase); std::smatch matches; for (std::sregex_iterator it(html.begin(), html.end(), pattern), end; it != end; ++it) downloadFile((*it)[1], path + \"/\" + getFileName((*it)[1])); }",
-"std::map<std::string, int> countWordFrequency(const std::string& text) { std::map<std::string, int> result; std::istringstream iss(text); std::string word; while (iss >> word) result[word]++; return result; }",
-"void simulateLogin(const std::string& url, const std::string& username, const std::string& password) { std::string command = \"curl -X POST -d 'username=\" + username + \"&password=\" + password + \"' \" + url; system(command.c_str()); }",
-"std::string htmlToText(const std::string& html) { std::regex pattern(\"<[^>]*>\"); return std::regex_replace(html, pattern, \"\"); }",
-"std::vector<std::string> extractEmails(const std::string& text) { std::regex pattern(\"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}\"); std::smatch matches; std::vector<std::string> result; for (std::sregex_iterator it(text.begin(), text.end(), pattern), end; it != end; ++it) result.push_back((*it)[0]); return result; }",
-"std::vector<std::string> extractPhoneNumbers(const std::string& text) { std::regex pattern(\"\\\\+?\\\\d{1,4}[-.\\\\s]?\\\\d{1,4}[-.\\\\s]?\\\\d{1,9}\"); std::smatch matches; std::vector<std::string> result; for (std::sregex_iterator it(text.begin(), text.end(), pattern), end; it != end; ++it) result.push_back((*it)[0]); return result; }",
-"std::vector<std::string> findAllNumbers(const std::string& text) { std::regex pattern(\"\\\\d+\"); std::smatch matches; std::vector<std::string> result; for (std::sregex_iterator it(text.begin(), text.end(), pattern), end; it != end; ++it) result.push_back((*it)[0]); return result; }",
-"std::string regexReplace(const std::string& text, const std::string& pattern, const std::string& replacement) { return std::regex_replace(text, std::regex(pattern), replacement); }",
-"bool matchesRegex(const std::string& text, const std::string& pattern) { return std::regex_match(text, std::regex(pattern)); }",
-"std::string removeHtmlTags(const std::string& html) { std::regex pattern(\"<[^>]*>\"); return std::regex_replace(html, pattern, \"\"); }",
-"std::string encodeHtmlEntities(const std::string& html) { std::string result; for (char c : html) { switch (c) { case '<': result += \"&lt;\"; break; case '>': result += \"&gt;\"; break; case '&': result += \"&amp;\"; break; case '\"': result += \"&quot;\"; break; case '\'': result += \"&apos;\"; break; default: result += c; } } return result; }",
-"std::string decodeHtmlEntities(const std::string& html) { std::string result = html; result = std::regex_replace(result, std::regex(\"&lt;\"), \"<\"); result = std::regex_replace(result, std::regex(\"&gt;\"), \">\"); result = std::regex_replace(result, std::regex(\"&amp;\"), \"&\"); result = std::regex_replace(result, std::regex(\"&quot;\"), \"\\\"\"); result = std::regex_replace(result, std::regex(\"&apos;\"), \"'\"); return result; }",
-"void createSimpleGUI() { Gtk::Window window; window.set_title(\"Simple GUI\"); window.set_default_size(200, 200); Gtk::Button button(\"Click Me\"); button.signal_clicked().connect([]() { std::cout << \"Button clicked\" << std::endl; }); window.add(button); window.show_all(); Gtk::Main::run(window); }",
-"void addButtonToWindow() { GtkWidget *button = gtk_button_new_with_label(\"Button\"); gtk_window_add(GTK_WINDOW(window), button); }",
-"void handleButtonClick() { g_signal_connect(button, \"clicked\", G_CALLBACK([]() { std::cout << \"Button clicked!\" << std::endl; }), NULL); }",
-"void showPopup() { GtkWidget *dialog = gtk_message_dialog_new(NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, \"Popup Message\"); gtk_dialog_run(GTK_DIALOG(dialog)); gtk_widget_destroy(dialog); }",
-"std::string getTextBoxInput() { const gchar *text = gtk_entry_get_text(GTK_ENTRY(entry)); return std::string(text); }",
-"void setWindowTitle(const std::string& title) { gtk_window_set_title(GTK_WINDOW(window), title.c_str()); }",
-"void setWindowSize(int width, int height) { gtk_window_set_default_size(GTK_WINDOW(window), width, height); }",
-"void centerWindow() { gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER); }",
-"void useMenuBar() { GtkWidget *menu_bar = gtk_menu_bar_new(); gtk_container_add(GTK_CONTAINER(window), menu_bar); }",
-"void createDropdown() { GtkWidget *combo = gtk_combo_box_text_new(); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), \"Option 1\"); gtk_container_add(GTK_CONTAINER(window), combo); }",
-"void useRadioButton() { GtkWidget *radio1 = gtk_radio_button_new_with_label(NULL, \"Option 1\"); gtk_container_add(GTK_CONTAINER(window), radio1); }",
-"void useCheckbox() { GtkWidget *check = gtk_check_button_new_with_label(\"Checkbox\"); gtk_container_add(GTK_CONTAINER(window), check); }",
-"void displayImage(const std::string& filePath) { GtkWidget *image = gtk_image_new_from_file(filePath.c_str()); gtk_container_add(GTK_CONTAINER(window), image); }",
-"void playAudio(const std::string& filePath) { system((\"mpg123 \" + filePath).c_str()); }",
-"void playVideo(const std::string& filePath) { system((\"vlc \" + filePath).c_str()); }",
-"int getCurrentPlaybackTime() { return 0; }",
-"void captureScreen() { system(\"import -window root screenshot.png\"); }",
-"void recordScreen(int duration) { system((\"ffmpeg -f x11grab -video_size 1920x1080 -i :0.0 -t \" + std::to_string(duration) + \" output.mp4\").c_str()); }",
-"std::pair<int, int> getMousePosition() { return {0, 0}; }",
-"void simulateKeyboardInput(const std::string& input) { system((\"xdotool type \" + input).c_str()); }",
-"void simulateMouseClick(int x, int y) { system((\"xdotool mousemove \" + std::to_string(x) + \" \" + std::to_string(y) + \" click 1\").c_str()); }",
-"time_t getCurrentTimestamp() { return time(nullptr); }",
-"std::string timestampToDate(time_t timestamp) { char buffer[80]; strftime(buffer, 80, \"%Y-%m-%d\", localtime(&timestamp)); return buffer; }",
-"time_t dateToTimestamp(const std::string& date) { struct tm tm; strptime(date.c_str(), \"%Y-%m-%d\", &tm); return mktime(&tm); }",
-"std::string getCurrentWeekday() { time_t now = time(nullptr); char buffer[80]; strftime(buffer, 80, \"%A\", localtime(&now)); return buffer; }",
-"int getDaysInMonth(int year, int month) { if (month == 2) return (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)) ? 29 : 28; else if (month == 4 || month == 6 || month == 9 || month == 11) return 30; else return 31; }",
-"std::string getFirstDayOfYear(int year) { char buffer[80]; strftime(buffer, 80, \"%Y-01-01\", localtime(&(time_t){0})); return buffer; }",
-"std::string getLastDayOfYear(int year) { char buffer[80]; strftime(buffer, 80, \"%Y-12-31\", localtime(&(time_t){0})); return buffer; }",
-"std::string getFirstDayOfMonth(int year, int month) { char buffer[80]; strftime(buffer, 80, \"%Y-%m-01\", localtime(&(time_t){0})); return buffer; }",
-"std::string getLastDayOfMonth(int year, int month) { int days = getDaysInMonth(year, month); char buffer[80]; snprintf(buffer, 80, \"%04d-%02d-%02d\", year, month, days); return buffer; }",
-"bool isWeekday() { time_t now = time(nullptr); struct tm* tm = localtime(&now); return tm->tm_wday >= 1 && tm->tm_wday <= 5; }",
-"bool isWeekend() { time_t now = time(nullptr); struct tm* tm = localtime(&now); return tm->tm_wday == 0 || tm->tm_wday == 6; }",
-"int getCurrentHour() { time_t now = time(nullptr); return localtime(&now)->tm_hour; }",
-"int getCurrentMinute() { time_t now = time(nullptr); return localtime(&now)->tm_min; }",
-"int getCurrentSecond() { time_t now = time(nullptr); return localtime(&now)->tm_sec; }",
-"void delay(int seconds) { sleep(seconds); }",
-"long getMillisecondTimestamp() { auto now = std::chrono::system_clock::now(); return std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count(); }",
-"std::string formatTime(const std::string& format) { time_t now = time(nullptr); char buffer[80]; strftime(buffer, 80, format.c_str(), localtime(&now)); return buffer; }",
-"time_t parseTime(const std::string& timeStr, const std::string& format) { struct tm tm; strptime(timeStr.c_str(), format.c_str(), &tm); return mktime(&tm); }",
-"void createThread(void (*func)()) { std::thread t(func); t.detach(); }",
-"void pauseThread() { std::this_thread::sleep_for(std::chrono::seconds(1)); }",
-"void runFunctionInThread(void (*func)()) { std::thread t(func); t.join(); }",
-"std::string getCurrentThreadName() { return \"\"; }",
-"void setThreadAsDaemon() { }",
-"void synchronizeThreads() { std::mutex mtx; mtx.lock(); mtx.unlock(); }",
-"void createProcess() { if (fork() == 0) { exit(0); } }",
-"int getProcessPID() { return getpid(); }",
-"bool isProcessAlive(int pid) { return kill(pid, 0) == 0; }",
-"void runFunctionInProcess(void (*func)()) { if (fork() == 0) { func(); exit(0); } }",
-"void useQueueForThreadCommunication() { std::queue<int> q; q.push(1); q.pop(); }",
-"void usePipeForCommunication() { int fd[2]; pipe(fd); }",
-"void limitCPUUsage() { }",
-"void runShellCommand(const std::string& command) { system(command.c_str()); }",
-"std::string getCommandOutput(const std::string& command) { std::string result; FILE* pipe = popen(command.c_str(), \"r\"); if (pipe) { char buffer[128]; while (fgets(buffer, sizeof(buffer), pipe) != nullptr) { result += buffer; } pclose(pipe); } return result; }",
-"int getCommandStatusCode(const std::string& command) { return system(command.c_str()); }",
-"bool isCommandSuccessful(const std::string& command) { return system(command.c_str()) == 0; }",
-"std::string getCurrentScriptPath() { return \"\"; }",
-"std::vector<std::string> getCommandLineArgs(int argc, char* argv[]) { return std::vector<std::string>(argv, argv + argc); }",
-"void useArgparse(int argc, char* argv[]) { }",
-"void generateCommandHelp() { }",
-"void listPythonModules() { }",
-"void installPythonPackage(const std::string& package) { system((\"pip install \" + package).c_str()); }",
-"void uninstallPythonPackage(const std::string& package) { system((\"pip uninstall \" + package).c_str()); }",
-"std::string getPackageVersion(const std::string& package) { return \"\"; }",
-"void useVirtualEnvironment() { system(\"python3 -m venv venv\"); }",
-"void listInstalledPackages() { system(\"pip list\"); }",
-"void upgradePythonPackage(const std::string& package) { system((\"pip install --upgrade \" + package).c_str()); }",
-"void connectToLocalDatabase() { sqlite3 *db; sqlite3_open(\":memory:\", &db); }",
-"void executeSQLQuery(const std::string& query) { sqlite3 *db; sqlite3_exec(db, query.c_str(), 0, 0, 0); }",
-"void insertRecord() { sqlite3 *db; sqlite3_exec(db, \"INSERT INTO table VALUES (1, 'value')\", 0, 0, 0); }",
-"void deleteRecord() { sqlite3 *db; sqlite3_exec(db, \"DELETE FROM table WHERE id = 1\", 0, 0, 0); }",
-"void updateRecord() { sqlite3 *db; sqlite3_exec(db, \"UPDATE table SET column = 'new_value' WHERE id = 1\", 0, 0, 0); }",
-"void queryMultipleRecords() { sqlite3 *db; sqlite3_exec(db, \"SELECT * FROM table\", 0, 0, 0); }",
-"void useParameterizedQuery() { sqlite3 *db; sqlite3_stmt *stmt; sqlite3_prepare_v2(db, \"SELECT * FROM table WHERE id = ?\", -1, &stmt, 0); }",
-"void closeDatabaseConnection() { sqlite3 *db; sqlite3_close(db); }",
-"void createTable() { sqlite3 *db; sqlite3_exec(db, \"CREATE TABLE table (id INT, column TEXT)\", 0, 0, 0); }",
-"void deleteTable() { sqlite3 *db; sqlite3_exec(db, \"DROP TABLE table\", 0, 0, 0); }",
-"bool tableExists() { return false; }",
-"void getAllTables() { sqlite3 *db; sqlite3_exec(db, \"SELECT name FROM sqlite_master WHERE type = 'table'\", 0, 0, 0); }",
-"void useORMInsert() { sqlite3 *db; sqlite3_exec(db, \"INSERT INTO table VALUES (1, 'value')\", 0, 0, 0); }",
-"void useORMQuery() { sqlite3 *db; sqlite3_exec(db, \"SELECT * FROM table\", 0, 0, 0); }",
-"void useORMDelete() { sqlite3 *db; sqlite3_exec(db, \"DELETE FROM table WHERE id = 1\", 0, 0, 0); }",
-"void useORMUpdate() { sqlite3 *db; sqlite3_exec(db, \"UPDATE table SET column = 'new_value' WHERE id = 1\", 0, 0, 0); }",
-"void defineModelClass() { struct Model { int id; std::string value; }; }",
-"void implementModelInheritance() { struct Base { int id; }; struct Derived : Base { std::string value; }; }",
-"void setPrimaryKeyField() { struct Model { int id; std::string value; }; }",
-"void setUniqueConstraint() { struct Model { int id; std::string value; }; }",
-"void setFieldDefaultValue() { struct Model { int id = 0; std::string value = \"default\"; }; }",
-"void exportToCSV() { std::ofstream file(\"data.csv\"); file << \"id,value\\n1,example\"; file.close(); }",
-"void exportToExcel() { std::ofstream file(\"data.xls\"); file << \"id\tvalue\n1\texample\"; file.close(); }",
-"void exportToJSON() { std::ofstream file(\"data.json\"); file << \"{\\\"id\\\":1,\\\"value\\\":\\\"example\\\"}\"; file.close(); }",
-"void readExcelData() { std::ifstream file(\"data.xls\"); std::string line; while (std::getline(file, line)) { std::cout << line << std::endl; } }",
-"void mergeExcelFiles() { std::ofstream merged(\"merged.xls\"); std::ifstream file1(\"data1.xls\"); std::ifstream file2(\"data2.xls\"); merged << file1.rdbuf() << file2.rdbuf(); }",
-"void addSheetToExcel() { std::ofstream file(\"data.xls\", std::ios::app); file << \"\\nNew Sheet\"; }",
-"void copyExcelStyle() { std::ifstream src(\"source.xls\"); std::ofstream dst(\"destination.xls\"); dst << src.rdbuf(); }",
-"void setExcelCellColor() { std::ofstream file(\"data.xls\", std::ios::app); file << \"\\nCell Color: Red\"; }",
-"void setExcelFontStyle() { std::ofstream file(\"data.xls\", std::ios::app); file << \"\\nFont Style: Bold\"; }",
-"void readExcelCellContent() { std::ifstream file(\"data.xls\"); std::string line; std::getline(file, line); std::cout << line << std::endl; }",
-"void writeExcelCellContent() { std::ofstream file(\"data.xls\", std::ios::app); file << \"\\nNew Content\"; }",
-"void getImageDimensions(const std::string& filePath) { std::ifstream file(filePath, std::ios::binary); file.seekg(16); int width, height; file.read((char*)&width, 4); file.read((char*)&height, 4); std::cout << \"Width: \" << width << \", Height: \" << height << std::endl; }",
-"void resizeImage(const std::string& filePath, int width, int height) { std::string command = \"convert \" + filePath + \" -resize \" + std::to_string(width) + \"x\" + std::to_string(height) + \" \" + filePath; system(command.c_str()); }"
+"Console.WriteLine("Hello, World!");",
+"""int Sum(int a,int b){
+return a+b;
+}""",
+"var rnd = new Random().Next();",
+"""bool IsEven(int n){
+return n % 2 == 0;
+}""",
+"int len = str.Length;",
+"DateTime today = DateTime.Today;",
+"bool exists = File.Exists(path);",
+"string content = File.ReadAllText(path);",
+"File.WriteAllText(path, content);",
+"DateTime now = DateTime.Now;",
+"string upper = s.ToUpper();",
+"string lower = s.ToLower();",
+"""string Reverse(string s){
+return new string(s.Reverse().ToArray());
+}""",
+"int count = list.Count;",
+"var max = list.Max();",
+"var min = list.Min();",
+"list.Sort();",
+"var merged = list1.Concat(list2).ToList();",
+"list.Remove(item);",
+"bool empty = !list.Any();",
+"""int CountChar(string s, char c){
+return s.Count(x => x == c);
+}""",
+"bool contains = s.Contains(sub);",
+"string s2 = num.ToString();",
+"int n2 = int.Parse(s);",
+"""bool IsNumber(string s){
+return int.TryParse(s, out );
+}""",
+"int idx = list.IndexOf(item);",
+"list.Clear();",
+"list.Reverse();",
+"var unique = list.Distinct().ToList();",
+"bool has = list.Contains(item);",
+"var dict = new Dictionary<string, object>();",
+"dict[key] = value;",
+"dict.Remove(key);",
+"var keys = dict.Keys;",
+"var values = dict.Values;",
+"var mergedDict = dict1.Concat(dict2).ToDictionary(kv => kv.Key, kv => kv.Value);",
+"bool dictEmpty = dict.Count == 0;",
+"var v = dict[key];",
+"bool hasKey = dict.ContainsKey(key);",
+"dict.Clear();",
+"int lines = File.ReadAllLines(path).Length;",
+"File.WriteAllLines(path, list);",
+"var list2 = File.ReadAllLines(path).ToList();",
+"int words = File.ReadAllText(path).Split().Length;",
+"""bool IsLeap(int y){
+return DateTime.IsLeapYear(y);
+}""",
+"string timeStr = DateTime.Now.ToString("HH:mm:ss");",
+"""int DaysBetween(DateTime a, DateTime b){
+return (int)(b - a).TotalDays;
+}""",
+"string cwd = Directory.GetCurrentDirectory();",
+"var files = Directory.GetFiles(path);",
+"Directory.CreateDirectory(path);",
+"Directory.Delete(path);",
+"bool isFile = File.Exists(path);",
+"bool isDir = Directory.Exists(path);",
+"long size = new FileInfo(path).Length;",
+"File.Move(oldPath, newPath);",
+"File.Copy(src, dest);",
+"File.Move(src, dest);",
+"File.Delete(path);",
+"string env = Environment.GetEnvironmentVariable(name);",
+"Environment.SetEnvironmentVariable(name, value);",
+"Process.Start(new ProcessStartInfo(url){ UseShellExecute = true });",
+"var response = await new HttpClient().GetAsync(url);",
+"dynamic obj = JsonConvert.DeserializeObject(json);",
+"File.WriteAllText(path, JsonConvert.SerializeObject(data));",
+"var data = JsonConvert.DeserializeObject(File.ReadAllText(path));",
+"string s3 = string.Join("", list);",
+"var list3 = s.ToCharArray().ToList();",
+"string s4 = string.Join(",", list);",
+"string s5 = string.Join(Environment.NewLine, list);",
+"var parts1 = s.Split(' ');",
+"var parts2 = s.Split(delimiter);",
+"var chars = s.ToCharArray();",
+"string r2 = s.Replace(oldValue, newValue);",
+"string r3 = s.Replace(" ","");",
+"""string RemovePunct(string s){
+return new string(s.Where(c => !char.IsPunctuation(c)).ToArray());
+}""",
+"bool strEmpty = string.IsNullOrEmpty(s);",
+"""bool IsPal(string s){
+var r = new string(s.Reverse().ToArray());
+return s == r;
+}""",
+"File.WriteAllLines(path, rows);",
+"var rows = File.ReadAllLines(path).Select(line => line.Split(',')).ToList();",
+"int csvLines = File.ReadAllLines(path).Length;",
+"""void Shuffle(List l){
+var r = new Random();
+for(int i = l.Count - 1; i > 0; i--){
+int j = r.Next(i + 1);
+var t = l[i];
+l[i] = l[j];
+l[j] = t;
+}
+}""",
+"var e = list[new Random().Next(list.Count)];",
+"var items = list.OrderBy(x => Guid.NewGuid()).Take(n).ToList();",
+"int dice = new Random().Next(1, 7);",
+"string coin = new Random().Next(2) == 0 ? "Heads" : "Tails";",
+"""string RandPwd(int l){
+const string chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+var r = new Random();
+return new string(Enumerable.Range(0, l).Select( => chars[r.Next(chars.Length)]).ToArray());
+}""",
+"""string RandColor(){
+var r = new Random();
+return $"#{r.Next(0x1000000):X6}";
+}""",
+"string id = Guid.NewGuid().ToString();",
+"""class MyClass{}""",
+"var obj2 = new MyClass();",
+"""class MyClass2{
+public void MyMethod(){}
+}""",
+"""class MyClass3{
+public int MyProperty { get; set; }
+}""",
+"""class SubClass : MyClass2{}""",
+"""class SubClass2 : MyClass2{
+public override void MyMethod(){}
+}""",
+"obj2.MyMethod();",
+"MyClass2.StaticMethod();",
+"bool isType = obj2 is MyClass2;",
+"var val2 = obj2.MyProperty;",
+"obj2.MyProperty = value;",
+"""((IDictionary<string, object>)obj2).Remove("MyProperty");"",
+"try { SomeMethod(); } catch(Exception ex) { Console.WriteLine(ex.Message); }",
+"""public class MyException:Exception{public MyException(string m):base(m){}}
+throw new MyException("error");""",
+"string message = ex.Message;",
+"File.AppendAllText("error.log", ex.ToString());",
+"""var sw=new System.Diagnostics.Stopwatch();
+sw.Start();""",
+"sw.Stop(); var elapsed = sw.Elapsed;",
+"""for(int i=0;i<=100;i++)
+{
+Console.Write($"\r[{new string('#',i/10).PadRight(10,' ')}] {i}%");
+}""",
+"System.Threading.Thread.Sleep(1000);",
+"Func<int,int> square = x => x * x;",
+"var mapped = list.Select(x => x * x);",
+"var filtered = list.Where(x => x % 2 == 0);",
+"var reduced = list.Aggregate((a, b) => a + b);",
+"var listComp = (from x in list select x * x).ToList();",
+"var dictComp = list.ToDictionary(x => x, x => x.ToString());",
+"var setComp = new HashSet(list.Select(x => x));",
+"var intersection = set1.Intersect(set2);",
+"var union = set1.Union(set2);",
+"var difference = set1.Except(set2);",
+"var noNulls = list.Where(x => x != null).ToList();",
+"""try
+{
+using(var fs=File.Open(path,FileMode.Open)){}
+}
+catch{}""",
+"if(obj is string) { /* type is string / }",
+"bool b = bool.Parse(s);",
+"if(x > 0) Console.WriteLine(x);",
+"while(condition) DoWork();",
+"foreach(var item in list) Console.WriteLine(item);",
+"foreach(var kv in dict) Console.WriteLine(kv.Key + ":" + kv.Value);",
+"foreach(var c in str) Console.Write(c);",
+"for(int i=0;i<10;i++){ if(i==5) break; }",
+"for(int i=0;i<10;i++){ if(i%2==0) continue; Console.Write(i); }",
+"int Add(int a,int b){return a+b;}",
+"int Mul(int a,int b=2){return ab;}",
+"(int min,int max) GetMinMax(int[] a){return (a.Min(),a.Max());}",
+"int Sum(params int[] a){return a.Sum();}",
+"""void Foo(int x,int y){}
+Foo(y:2,x:1);""",
+"""T Timed(Func fn)
+{
+var sw=new System.Diagnostics.Stopwatch();
+sw.Start();
+var result=fn();
+sw.Stop();
+Console.WriteLine(sw.Elapsed);
+return result;
+}""",
+"""Func<int,int> memoized = null;
+var cache = new Dictionary<int,int>();
+memoized = x => cache.ContainsKey(x)?cache[x]:(cache[x]=x* x);""",
+"""IEnumerable Gen()
+{
+for(int i=0;i<10;i++) yield return i;
+}""",
+"var e = Gen().GetEnumerator(); e.MoveNext(); var first = e.Current;",
+"""class MyCollection : IEnumerable
+{
+int[] data={1,2,3};
+public IEnumerator GetEnumerator(){foreach(var i in data)yield return i;}
+IEnumerator IEnumerable.GetEnumerator()=>GetEnumerator();
+}""",
+"""var enumerator = list.GetEnumerator();
+while(enumerator.MoveNext()) Console.WriteLine(enumerator.Current);""",
+"foreach(var t in list.Select((v,i)=>new{v,i})) Console.WriteLine(t.i+":"+t.v);",
+"var zipped = list1.Zip(list2,(a,b)=>(a,b));",
+"var toDict = list1.Zip(list2,(a,b)=>new{a,b}).ToDictionary(x=>x.a,x=>x.b);",
+"bool eqList = list1.SequenceEqual(list2);",
+"bool eqDict = dict1.Count==dict2.Count && !dict1.Except(dict2).Any();",
+"bool eqSet = set1.SetEquals(set2);",
+"var unique = list.Distinct().ToList();",
+"set.Clear();",
+"bool isEmpty = set.Count==0;",
+"set.Add(item);",
+"set.Remove(item);",
+"bool contains = set.Contains(item);",
+"int count = set.Count;",
+"bool hasOverlap = set1.Overlaps(set2);",
+"bool isSubset = new HashSet(list1).IsSupersetOf(list2);",
+"bool isSubstring = str.Contains(sub);",
+"char first = str[0];",
+"char last = str[^1];",
+"bool isText = Path.GetExtension(path)==\".txt\";",
+"bool isImage = new[]{\".png\",\".jpg\",\".jpeg\",\".gif\"}.Contains(Path.GetExtension(path));",
+"double rounded = Math.Round(d);",
+"double up = Math.Ceiling(d);",
+"double down = Math.Floor(d);",
+"string formatted = d.ToString(\"F2\");",
+"""var rnd=new Random();
+var s=new string(Enumerable.Range(0,8).Select(_=>"ABCDEFGHIJKLMNOPQRSTUVWXYZ"[rnd.Next(26)]).ToArray());""",
+"bool exists = File.Exists(path)||Directory.Exists(path);",
+"var files = Directory.GetFiles(dir, "", SearchOption.AllDirectories);",
+"string ext = Path.GetExtension(path);",
+"string name = Path.GetFileName(path);",
+"string full = Path.GetFullPath(path);",
+"""var p=new Process{
+StartInfo=new ProcessStartInfo("python","--version"){
+RedirectStandardOutput=true
+}
+};
+p.Start();
+string version=p.StandardOutput.ReadToEnd();""",
+"string osInfo = Environment.OSVersion.ToString();",
+"int cores = Environment.ProcessorCount;",
+"ulong mem = new Microsoft.VisualBasic.Devices.ComputerInfo().TotalPhysicalMemory;",
+"""var usage = DriveInfo.GetDrives()
+.Select(d=>new{d.Name,d.TotalSize,d.AvailableFreeSpace});""",
+"var ip = Dns.GetHostEntry(Dns.GetHostName()).AddressList.First(a=>a.AddressFamily==System.Net.Sockets.AddressFamily.InterNetwork);",
+"bool online = new System.Net.NetworkInformation.Ping().Send("8.8.8.8").Status==System.Net.NetworkInformation.IPStatus.Success;",
+"new WebClient().DownloadFile(url,path);",
+"Console.WriteLine(\"Uploading \"+path);",
+"var response=await new HttpClient().PostAsync(url,new StringContent(data));",
+"var getResponse=await new HttpClient().GetAsync(url+"?"+query);",
+"var client=new HttpClient(); client.DefaultRequestHeaders.Add("Header","Value");",
+"""var doc=new HtmlAgilityPack.HtmlDocument();
+doc.LoadHtml(html);""",
+"string title=doc.DocumentNode.SelectSingleNode(\"//title\").InnerText;",
+"var links=doc.DocumentNode.SelectNodes(\"//a[@href]\").Select(n=>n.Attributes[\"href\"].Value);",
+"""foreach(var img in links.Where(u=>u.EndsWith(".png")||u.EndsWith(".jpg")))
+new WebClient().DownloadFile(img,Path.GetFileName(img));""",
+"""var freq=text.Split()
+.GroupBy(w=>w)
+.ToDictionary(g=>g.Key,g=>g.Count());""",
+"""var loginResponse=await client.PostAsync(loginUrl,new FormUrlEncodedContent(new[]{new KeyValuePair<string,string>("user",u),("pass",p)}));
+var content=await loginResponse.Content.ReadAsStringAsync();""",
+"string plain=Regex.Replace(html,\"<.?>\"," ");",
+"var emails=Regex.Matches(text,\"[\w.-]+@[\w.-]+\.[A-Za-z]{2,6}\");",
+"var phones=Regex.Matches(text,"\d{3}-\d{4}-\d{4}");",
+"var numbers=Regex.Matches(text,"\d+");",
+"string replaced=Regex.Replace(text,"old","new");",
+"bool isMatch=Regex.IsMatch(text,pattern);",
+"string noTags=Regex.Replace(html,\"<.*?>\"," ");",
+"string encoded=System.Net.WebUtility.HtmlEncode(s);",
+"string decoded=System.Net.WebUtility.HtmlDecode(s);",
+"""var form=new System.Windows.Forms.Form();
+System.Windows.Forms.Application.Run(form);""",
+"var button = new Button { Text = \"Click Me\" }; window.Controls.Add(button);",
+    "button.Click += (sender, e) => { MessageBox.Show(\"Button Clicked!\"); };",
+    "MessageBox.Show(\"This is a popup message!\");",
+    "var input = textBox.Text;",
+    "window.Text = \"New Window Title\";",
+    "window.Size = new Size(800, 600);",
+    "window.StartPosition = FormStartPosition.CenterScreen;",
+    "var menuStrip = new MenuStrip(); window.Controls.Add(menuStrip);",
+    "var comboBox = new ComboBox(); window.Controls.Add(comboBox);",
+    "var radioButton = new RadioButton { Text = \"Option 1\" }; window.Controls.Add(radioButton);",
+    "var checkBox = new CheckBox { Text = \"Check Me\" }; window.Controls.Add(checkBox);",
+    "var pictureBox = new PictureBox { Image = Image.FromFile(\"image.jpg\") }; window.Controls.Add(pictureBox);",
+    "var player = new SoundPlayer(\"audio.wav\"); player.Play();",
+    "var player = new AxWMPLib.AxWindowsMediaPlayer(); player.URL = \"video.mp4\"; window.Controls.Add(player);",
+    "var currentTime = player.Ctlcontrols.currentPosition;",
+    "var bmp = new Bitmap(Screen.PrimaryScreen.Bounds.Width, Screen.PrimaryScreen.Bounds.Height); var g = Graphics.FromImage(bmp); g.CopyFromScreen(0, 0, 0, 0, bmp.Size); bmp.Save(\"screenshot.png\");",
+    "var recorder = new ScreenRecorder(); recorder.StartRecording(); Thread.Sleep(5000); recorder.StopRecording();",
+    "var mousePos = Cursor.Position;",
+    "SendKeys.Send(\"Hello World\");",
+    "Cursor.Position = new Point(100, 100); mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0); mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);",
+    "var timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds();",
+    "var date = DateTimeOffset.FromUnixTimeSeconds(timestamp).DateTime;",
+    "var timestamp = new DateTimeOffset(date).ToUnixTimeSeconds();",
+    "var dayOfWeek = DateTime.Now.DayOfWeek;",
+    "var daysInMonth = DateTime.DaysInMonth(DateTime.Now.Year, DateTime.Now.Month);",
+    "var firstDayOfYear = new DateTime(DateTime.Now.Year, 1, 1);",
+    "var lastDayOfYear = new DateTime(DateTime.Now.Year, 12, 31);",
+    "var firstDayOfMonth = new DateTime(DateTime.Now.Year, DateTime.Now.Month, 1);",
+    "var lastDayOfMonth = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.DaysInMonth(DateTime.Now.Year, DateTime.Now.Month));",
+    "var isWeekday = DateTime.Now.DayOfWeek != DayOfWeek.Saturday && DateTime.Now.DayOfWeek != DayOfWeek.Sunday;",
+    "var isWeekend = DateTime.Now.DayOfWeek == DayOfWeek.Saturday || DateTime.Now.DayOfWeek == DayOfWeek.Sunday;",
+    "var currentHour = DateTime.Now.Hour;",
+    "var currentMinute = DateTime.Now.Minute;",
+    "var currentSecond = DateTime.Now.Second;",
+    "Thread.Sleep(1000);",
+    "var millisTimestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();",
+    "var formattedTime = DateTime.Now.ToString(\"yyyy-MM-dd HH:mm:ss\");",
+    "var parsedTime = DateTime.Parse(\"2023-10-01 12:00:00\");",
+    "var thread = new Thread(() => { }); thread.Start();",
+    "Thread.Sleep(1000);",
+    "Parallel.Invoke(() => { }, () => { });",
+    "var threadName = Thread.CurrentThread.Name;",
+    "thread.IsBackground = true;",
+    "var lockObj = new object(); lock (lockObj) { }",
+    "var process = Process.Start(\"notepad.exe\");",
+    "var pid = process.Id;",
+    "var isAlive = !process.HasExited;",
+    "Parallel.Invoke(() => { }, () => { });",
+    "var queue = new Queue<int>(); queue.Enqueue(1); var value = queue.Dequeue();",
+    "var pipe = new AnonymousPipeServerStream();",
+    "Process.GetCurrentProcess().ProcessorAffinity = (IntPtr)1;",
+    "var process = Process.Start(\"cmd.exe\", \"/c dir\");",
+    "var output = process.StandardOutput.ReadToEnd();",
+    "var exitCode = process.ExitCode;",
+    "var isSuccess = exitCode == 0;",
+    "var scriptPath = System.Reflection.Assembly.GetExecutingAssembly().Location;",
+    "var args = Environment.GetCommandLineArgs();",
+    "var parser = new ArgumentParser(); var args = parser.ParseArgs();",
+    "var help = parser.PrintHelp();",
+    "var modules = AppDomain.CurrentDomain.GetAssemblies();",
+    "Process.Start(\"pip\", \"install package_name\").WaitForExit();",
+    "Process.Start(\"pip\", \"uninstall package_name\").WaitForExit();",
+    "var version = Assembly.GetExecutingAssembly().GetName().Version;",
+    "Process.Start(\"python\", \"-m venv venv\").WaitForExit();",
+    "var packages = Process.Start(\"pip\", \"list\").StandardOutput.ReadToEnd();",
+    "Process.Start(\"pip\", \"install --upgrade package_name\").WaitForExit();",
+    "var connection = new SqlConnection(\"Server=localhost;Database=test;User Id=sa;Password=password;\"); connection.Open();",
+    "var command = new SqlCommand(\"SELECT * FROM table\", connection); var reader = command.ExecuteReader();",
+    "var command = new SqlCommand(\"INSERT INTO table (column) VALUES ('value')\", connection); command.ExecuteNonQuery();",
+    "var command = new SqlCommand(\"DELETE FROM table WHERE id = 1\", connection); command.ExecuteNonQuery();",
+    "var command = new SqlCommand(\"UPDATE table SET column = 'value' WHERE id = 1\", connection); command.ExecuteNonQuery();",
+    "var command = new SqlCommand(\"SELECT * FROM table\", connection); var reader = command.ExecuteReader(); while (reader.Read()) { }",
+    "var command = new SqlCommand(\"SELECT * FROM table WHERE column = @value\", connection); command.Parameters.AddWithValue(\"@value\", \"value\"); var reader = command.ExecuteReader();",
+    "connection.Close();",
+    "var command = new SqlCommand(\"CREATE TABLE table (id INT PRIMARY KEY, column VARCHAR(255))\", connection); command.ExecuteNonQuery();",
+    "var command = new SqlCommand(\"DROP TABLE table\", connection); command.ExecuteNonQuery();",
+    "var exists = connection.GetSchema(\"Tables\").Rows.Cast<DataRow>().Any(row => row[\"TABLE_NAME\"].ToString() == \"table\");",
+    "var tables = connection.GetSchema(\"Tables\").Rows.Cast<DataRow>().Select(row => row[\"TABLE_NAME\"].ToString()).ToList();",
+    "var context = new DbContext(); context.Table.Add(new Model { Column = \"value\" }); context.SaveChanges();",
+    "var data = context.Table.Where(x => x.Column == \"value\").ToList();",
+    "var entity = context.Table.First(x => x.Id == 1); context.Table.Remove(entity); context.SaveChanges();",
+    "var entity = context.Table.First(x => x.Id == 1); entity.Column = \"new_value\"; context.SaveChanges();",
+    "public class Model { public int Id { get; set; } public string Column { get; set; } }",
+    "public class DerivedModel : Model { public string NewColumn { get; set; } }",
+    "public class Model { [Key] public int Id { get; set; } }",
+    "public class Model { [Unique] public string Column { get; set; } }",
+    "public class Model { public string Column { get; set; } = \"default_value\"; }",
+    "File.WriteAllLines(\"data.csv\", data.Select(x => string.Join(\",\", x)));",
+    "var workbook = new XLWorkbook(); var worksheet = workbook.Worksheets.Add(\"Sheet1\"); worksheet.Cell(1, 1).Value = \"Data\"; workbook.SaveAs(\"data.xlsx\");",
+    "var json = JsonConvert.SerializeObject(data); File.WriteAllText(\"data.json\", json);",
+    "var workbook = new XLWorkbook(\"data.xlsx\"); var worksheet = workbook.Worksheet(1); var data = worksheet.Rows().Select(row => row.Cell(1).Value.ToString()).ToList();",
+    "var mergedWorkbook = new XLWorkbook(); foreach (var file in files) { var workbook = new XLWorkbook(file); mergedWorkbook.AddWorksheet(workbook.Worksheet(1)); } mergedWorkbook.SaveAs(\"merged.xlsx\");",
+    "var workbook = new XLWorkbook(); var worksheet = workbook.Worksheets.Add(\"NewSheet\"); workbook.SaveAs(\"data.xlsx\");",
+    "var workbook = new XLWorkbook(\"data.xlsx\"); var worksheet = workbook.Worksheet(1); var style = worksheet.Cell(1, 1).Style; worksheet.Cell(2, 2).Style = style; workbook.SaveAs(\"data.xlsx\");",
+    "var workbook = new XLWorkbook(\"data.xlsx\"); var worksheet = workbook.Worksheet(1); worksheet.Cell(1, 1).Style.Fill.BackgroundColor = XLColor.Red; workbook.SaveAs(\"data.xlsx\");",
+    "var workbook = new XLWorkbook(\"data.xlsx\"); var worksheet = workbook.Worksheet(1); worksheet.Cell(1, 1).Style.Font.FontColor = XLColor.Blue; workbook.SaveAs(\"data.xlsx\");",
+    "var workbook = new XLWorkbook(\"data.xlsx\"); var worksheet = workbook.Worksheet(1); var content = worksheet.Cell(1, 1).Value.ToString();",
+    "var workbook = new XLWorkbook(\"data.xlsx\"); var worksheet = workbook.Worksheet(1); worksheet.Cell(1, 1).Value = \"New Content\"; workbook.SaveAs(\"data.xlsx\");",
+    "var image = Image.FromFile(\"image.jpg\"); var width = image.Width; var height = image.Height;",
+    "var image = Image.FromFile(\"image.jpg\"); var resizedImage = new Bitmap(image, new Size(100, 100)); resizedImage.Save(\"resized.jpg\");"
+
+