Update app.py

app.py

@@ -14,306 +14,341 @@ 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()); }"
+ "#include <stdio.h>\nvoid print_text() { printf(\"Hello, World!\"); }",
+    "#include <stdio.h>\nint sum(int a, int b) { return a + b; }",
+    "#include <stdlib.h>\n#include <time.h>\nint generate_random() { srand(time(NULL)); return rand(); }",
+    "#include <stdio.h>\nint is_even(int num) { return num % 2 == 0; }",
+    "#include <string.h>\nint string_length(char *str) { return strlen(str); }",
+    "#include <time.h>\nvoid get_current_date() { time_t t = time(NULL); printf(\"%s\", ctime(&t)); }",
+    "#include <stdio.h>\nint file_exists(char *filename) { FILE *file = fopen(filename, \"r\"); if (file) { fclose(file); return 1; } return 0; }",
+    "#include <stdio.h>\nvoid read_file(char *filename) { FILE *file = fopen(filename, \"r\"); char ch; while ((ch = fgetc(file)) != EOF) { putchar(ch); } fclose(file); }",
+    "#include <stdio.h>\nvoid write_file(char *filename, char *content) { FILE *file = fopen(filename, \"w\"); fprintf(file, \"%s\", content); fclose(file); }",
+    "#include <time.h>\nvoid get_current_time() { time_t t = time(NULL); printf(\"%s\", ctime(&t)); }",
+    "#include <ctype.h>\nvoid to_upper(char *str) { for (int i = 0; str[i]; i++) { str[i] = toupper(str[i]); } }",
+    "#include <ctype.h>\nvoid to_lower(char *str) { for (int i = 0; str[i]; i++) { str[i] = tolower(str[i]); } }",
+    "#include <string.h>\nvoid reverse_string(char *str) { int len = strlen(str); for (int i = 0; i < len / 2; i++) { char temp = str[i]; str[i] = str[len - i - 1]; str[len - i - 1] = temp; } }",
+    "#include <stdio.h>\nint list_length(int *arr, int size) { return size; }",
+    "#include <limits.h>\nint list_max(int *arr, int size) { int max = INT_MIN; for (int i = 0; i < size; i++) { if (arr[i] > max) max = arr[i]; } return max; }",
+    "#include <limits.h>\nint list_min(int *arr, int size) { int min = INT_MAX; for (int i = 0; i < size; i++) { if (arr[i] < min) min = arr[i]; } return min; }",
+    "#include <stdlib.h>\nvoid sort_list(int *arr, int size) { qsort(arr, size, sizeof(int), (int (*)(const void *, const void *))strcmp); }",
+    "#include <stdio.h>\nvoid merge_lists(int *arr1, int size1, int *arr2, int size2, int *result) { memcpy(result, arr1, size1 * sizeof(int)); memcpy(result + size1, arr2, size2 * sizeof(int)); }",
+    "#include <stdio.h>\nvoid remove_element(int *arr, int *size, int index) { for (int i = index; i < *size - 1; i++) { arr[i] = arr[i + 1]; } (*size)--; }",
+    "#include <stdio.h>\nint is_list_empty(int *arr, int size) { return size == 0; }",
+    "#include <string.h>\nint count_char(char *str, char ch) { int count = 0; for (int i = 0; str[i]; i++) { if (str[i] == ch) count++; } return count; }",
+    "#include <string.h>\nint contains_substring(char *str, char *sub) { return strstr(str, sub) != NULL; }",
+    "#include <stdlib.h>\nvoid int_to_string(int num, char *str) { sprintf(str, \"%d\", num); }",
+    "#include <stdlib.h>\nint string_to_int(char *str) { return atoi(str); }",
+    "#include <ctype.h>\nint is_numeric(char *str) { for (int i = 0; str[i]; i++) { if (!isdigit(str[i])) return 0; } return 1; }",
+    "#include <stdio.h>\nint find_index(int *arr, int size, int value) { for (int i = 0; i < size; i++) { if (arr[i] == value) return i; } return -1; }",
+    "#include <stdio.h>\nvoid clear_list(int *arr, int *size) { *size = 0; }",
+    "#include <stdio.h>\nvoid reverse_list(int *arr, int size) { for (int i = 0; i < size / 2; i++) { int temp = arr[i]; arr[i] = arr[size - i - 1]; arr[size - i - 1] = temp; } }",
+    "#include <stdio.h>\nvoid remove_duplicates(int *arr, int *size) { for (int i = 0; i < *size; i++) { for (int j = i + 1; j < *size; j++) { if (arr[i] == arr[j]) { remove_element(arr, size, j); j--; } } } }",
+    "#include <stdio.h>\nint is_in_list(int *arr, int size, int value) { for (int i = 0; i < size; i++) { if (arr[i] == value) return 1; } return 0; }",
+    "#include <stdio.h>\nvoid create_dict() { }",
+    "#include <stdio.h>\nvoid add_to_dict() { }",
+    "#include <stdio.h>\nvoid delete_from_dict() { }",
+    "#include <stdio.h>\nvoid get_dict_keys() { }",
+    "#include <stdio.h>\nvoid get_dict_values() { }",
+    "#include <stdio.h>\nvoid merge_dicts() { }",
+    "#include <stdio.h>\nint is_dict_empty() { return 1; }",
+    "#include <stdio.h>\nvoid get_dict_value() { }",
+    "#include <stdio.h>\nint key_in_dict() { return 1; }",
+    "#include <stdio.h>\nvoid clear_dict() { }",
+    "#include <stdio.h>\nint count_file_lines(char *filename) { FILE *file = fopen(filename, \"r\"); int count = 0; char ch; while ((ch = fgetc(file)) != EOF) { if (ch == '\\n') count++; } fclose(file); return count; }",
+    "#include <stdio.h>\nvoid write_list_to_file(char *filename, int *arr, int size) { FILE *file = fopen(filename, \"w\"); for (int i = 0; i < size; i++) { fprintf(file, \"%d\\n\", arr[i]); } fclose(file); }",
+    "#include <stdio.h>\nvoid read_list_from_file(char *filename, int *arr, int *size) { FILE *file = fopen(filename, \"r\"); *size = 0; while (fscanf(file, \"%d\", &arr[*size]) != EOF) { (*size)++; } fclose(file); }",
+    "#include <stdio.h>\nint count_file_words(char *filename) { FILE *file = fopen(filename, \"r\"); int count = 0; char ch; while ((ch = fgetc(file)) != EOF) { if (ch == ' ') count++; } fclose(file); return count + 1; }",
+    "#include <stdio.h>\nint is_leap_year(int year) { return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0); }",
+    "#include <time.h>\nvoid format_time() { time_t t = time(NULL); struct tm *tm = localtime(&t); char buffer[80]; strftime(buffer, 80, \"%Y-%m-%d %H:%M:%S\", tm); printf(\"%s\", buffer); }",
+    "#include <time.h>\nint days_between_dates(struct tm *date1, struct tm *date2) { return (int)(difftime(mktime(date1), mktime(date2)) / (60 * 60 * 24)); }",
+    "#include <unistd.h>\nvoid get_current_directory() { char cwd[1024]; getcwd(cwd, sizeof(cwd)); printf(\"%s\", cwd); }",
+    "#include <dirent.h>\nvoid list_directory_files(char *path) { DIR *dir = opendir(path); struct dirent *entry; while ((entry = readdir(dir)) != NULL) { printf(\"%s\\n\", entry->d_name); } closedir(dir); }",
+    "#include <sys/stat.h>\nvoid create_directory(char *path) { mkdir(path, 0777); }",
+    "#include <unistd.h>\nvoid delete_directory(char *path) { rmdir(path); }",
+    "#include <sys/stat.h>\nint is_file(char *path) { struct stat path_stat; stat(path, &path_stat); return S_ISREG(path_stat.st_mode); }",
+    "#include <sys/stat.h>\nint is_directory(char *path) { struct stat path_stat; stat(path, &path_stat); return S_ISDIR(path_stat.st_mode); }",
+    "#include <sys/stat.h>\nlong get_file_size(char *filename) { struct stat st; stat(filename, &st); return st.st_size; }",
+    "#include <stdio.h>\nvoid rename_file(char *old_name, char *new_name) { rename(old_name, new_name); }",
+    "#include <stdio.h>\nvoid copy_file(char *src, char *dest) { FILE *fsrc = fopen(src, \"rb\"); FILE *fdest = fopen(dest, \"wb\"); char ch; while ((ch = fgetc(fsrc)) != EOF) { fputc(ch, fdest); } fclose(fsrc); fclose(fdest); }",
+    "#include <stdio.h>\nvoid move_file(char *src, char *dest) { rename(src, dest); }",
+    "#include <stdio.h>\nvoid delete_file(char *filename) { remove(filename); }",
+    "#include <stdlib.h>\nvoid get_env_var(char *var) { printf(\"%s\", getenv(var)); }",
+    "#include <stdlib.h>\nvoid set_env_var(char *var, char *value) { setenv(var, value, 1); }",
+    "#include <stdio.h>\nvoid open_url(char *url) { char command[256]; sprintf(command, \"xdg-open %s\", url); system(command); }",
+    "#include <stdio.h>\n#include <curl/curl.h>\nvoid send_get_request(char *url) { CURL *curl = curl_easy_init(); if(curl) { curl_easy_setopt(curl, CURLOPT_URL, url); curl_easy_perform(curl); curl_easy_cleanup(curl); } }",
+    "#include <stdio.h>\n#include <json-c/json.h>\nvoid parse_json(char *json_str) { json_object *jobj = json_tokener_parse(json_str); printf(\"%s\", json_object_to_json_string(jobj)); }",
+    "#include <stdio.h>\n#include <json-c/json.h>\nvoid write_json_to_file(char *filename, json_object *jobj) { FILE *file = fopen(filename, \"w\"); fprintf(file, \"%s\", json_object_to_json_string(jobj)); fclose(file); }",
+    "#include <stdio.h>\n#include <json-c/json.h>\nvoid read_json_from_file(char *filename) { FILE *file = fopen(filename, \"r\"); char buffer[1024]; fread(buffer, 1, sizeof(buffer), file); fclose(file); json_object *jobj = json_tokener_parse(buffer); printf(\"%s\", json_object_to_json_string(jobj)); }",
+    "#include <stdio.h>\nvoid list_to_string(int *arr, int size, char *str) { for (int i = 0; i < size; i++) { sprintf(str + strlen(str), \"%d \", arr[i]); } }",
+    "#include <stdio.h>\nvoid string_to_list(char *str, int *arr, int *size) { *size = 0; char *token = strtok(str, \" \"); while (token != NULL) { arr[*size] = atoi(token); (*size)++; token = strtok(NULL, \" \"); } }",
+    "#include <stdio.h>\nvoid join_with_comma(int *arr, int size, char *str) { for (int i = 0; i < size; i++) { sprintf(str + strlen(str), \"%d,\", arr[i]); } str[strlen(str) - 1] = '\\0'; }",
+    "#include <stdio.h>\nvoid join_with_newline(int *arr, int size, char *str) { for (int i = 0; i < size; i++) { sprintf(str + strlen(str), \"%d\\n\", arr[i]); } }",
+    "#include <stdio.h>\nvoid split_by_space(char *str, char **arr, int *size) { *size = 0; char *token = strtok(str, \" \"); while (token != NULL) { arr[*size] = token; (*size)++; token = strtok(NULL, \" \"); } }",
+    "#include <stdio.h>\nvoid split_by_delimiter(char *str, char *delimiter, char **arr, int *size) { *size = 0; char *token = strtok(str, delimiter); while (token != NULL) { arr[*size] = token; (*size)++; token = strtok(NULL, delimiter); } }",
+    "#include <stdio.h>\nvoid split_to_chars(char *str, char *arr) { for (int i = 0; str[i]; i++) { arr[i] = str[i]; } }",
+    "#include <stdio.h>\nvoid replace_string(char *str, char *old, char *new) { char *pos = strstr(str, old); if (pos) { memmove(pos + strlen(new), pos + strlen(old), strlen(pos + strlen(old)) + 1); memcpy(pos, new, strlen(new)); } }",
+    "#include <stdio.h>\nvoid remove_spaces(char *str) { int count = 0; for (int i = 0; str[i]; i++) { if (str[i] != ' ') str[count++] = str[i]; } str[count] = '\\0'; }",
+    "#include <ctype.h>\nvoid remove_punctuation(char *str) { int count = 0; for (int i = 0; str[i]; i++) { if (!ispunct(str[i])) str[count++] = str[i]; } str[count] = '\\0'; }",
+    "#include <stdio.h>\nint is_string_empty(char *str) { return strlen(str) == 0; }",
+    "#include <stdio.h>\nint is_palindrome(char *str) { int len = strlen(str); for (int i = 0; i < len / 2; i++) { if (str[i] != str[len - i - 1]) return 0; } return 1; }",
+    "#include <stdio.h>\nvoid write_csv(char *filename, int *arr, int size) { FILE *file = fopen(filename, \"w\"); for (int i = 0; i < size; i++) { fprintf(file, \"%d,\", arr[i]); } fclose(file); }",
+    "#include <stdio.h>\nvoid read_csv(char *filename, int *arr, int *size) { FILE *file = fopen(filename, \"r\"); *size = 0; while (fscanf(file, \"%d,\", &arr[*size]) != EOF) { (*size)++; } fclose(file); }",
+    "#include <stdio.h>\nint count_csv_lines(char *filename) { FILE *file = fopen(filename, \"r\"); int count = 0; char ch; while ((ch = fgetc(file)) != EOF) { if (ch == '\\n') count++; } fclose(file); return count; }",
+    "#include <stdlib.h>\nvoid shuffle_list(int *arr, int size) { for (int i = 0; i < size; i++) { int j = rand() % size; int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } }",
+    "#include <stdlib.h>\nint random_element(int *arr, int size) { return arr[rand() % size]; }",
+    "#include <stdlib.h>\nvoid random_elements(int *arr, int size, int *result, int count) { for (int i = 0; i < count; i++) { result[i] = arr[rand() % size]; } }",
+    "#include <stdlib.h>\nint roll_dice() { return rand() % 6 + 1; }",
+    "#include <stdlib.h>\nint flip_coin() { return rand() % 2; }",
+    "#include <stdlib.h>\nvoid generate_password(char *password, int length) { for (int i = 0; i < length; i++) { password[i] = rand() % 94 + 33; } password[length] = '\\0'; }",
+    "#include <stdlib.h>\nvoid generate_color(char *color) { sprintf(color, \"#%06X\", rand() % 0xFFFFFF); }",
+    "#include <stdlib.h>\nvoid generate_uuid(char *uuid) { sprintf(uuid, \"%04x%04x-%04x-%04x-%04x-%04x%04x%04x\", rand() % 0xFFFF, rand() % 0xFFFF, rand() % 0xFFFF, rand() % 0xFFFF, rand() % 0xFFFF, rand() % 0xFFFF, rand() % 0xFFFF, rand() % 0xFFFF); }",
+    """typedef struct {
+    int id;
+    char name[50];
+} MyClass;""",
+    """MyClass create_instance(int id, char *name) {
+    MyClass instance;
+    instance.id = id;
+    strcpy(instance.name, name);
+    return instance;
+}""",
+    """void my_method(MyClass *obj) {
+    printf("Method called with ID: %d, Name: %s\\n", obj->id, obj->name);
+}""",
+    """typedef struct {
+    int id;
+    char name[50];
+} MyClass;""",
+    """typedef struct {
+    MyClass base;
+    int additionalField;
+} DerivedClass;""",
+    """void overridden_method(DerivedClass *obj) {
+    printf("Overridden method called with additional field: %d\\n", obj->additionalField);
+}""",
+    """void class_method() {
+    printf("Class method called\\n");
+}""",
+    """void static_method() {
+    printf("Static method called\\n");
+}""",
+    """int is_type(MyClass *obj, const char *type) {
+    return strcmp(type, "MyClass") == 0;
+}""",
+    """int get_property(MyClass *obj, const char *property) {
+    if (strcmp(property, "id") == 0) return obj->id;
+    if (strcmp(property, "name") == 0) return (int)obj->name;
+    return -1;
+}""",
+    """void set_property(MyClass *obj, const char *property, int value) {
+    if (strcmp(property, "id") == 0) obj->id = value;
+}""",
+    """void delete_property(MyClass *obj, const char *property) {
+    if (strcmp(property, "id") == 0) obj->id = 0;
+}""",
+"#include <setjmp.h>\njmp_buf env;\n#define TRY if (setjmp(env) == 0)\n#define CATCH else",
+"#define THROW longjmp(env, 1)",
+"#include <stdio.h>\n#define GET_EXCEPTION_INFO fprintf(stderr, \"Exception occurred\\n\")",
+"#include <stdio.h>\n#define LOG_ERROR(msg) fprintf(stderr, \"ERROR: %s\\n\", msg)",
+"#include <time.h>\nclock_t start_timer() { return clock(); }",
+"double get_elapsed_time(clock_t start) { return (double)(clock() - start) / CLOCKS_PER_SEC; }",
+"#include <stdio.h>\nvoid print_progress_bar(int progress, int total) { printf(\"[%.*s%*s] %d%%\\r\", progress * 20 / total, \"==================\", 20 - progress * 20 / total, \"\", progress * 100 / total); fflush(stdout); }",
+"#include <unistd.h>\nvoid delay(unsigned int seconds) { sleep(seconds); }",
+"#define LAMBDA(return_type, body) ({ return_type __fn__ body __fn__; })",
+"#include <stdlib.h>\nint* map(int* arr, size_t size, int (*func)(int)) { int* result = malloc(size * sizeof(int)); for (size_t i = 0; i < size; i++) result[i] = func(arr[i]); return result; }",
+"#include <stdlib.h>\nint* filter(int* arr, size_t size, int (*func)(int), size_t* result_size) { int* result = malloc(size * sizeof(int)); *result_size = 0; for (size_t i = 0; i < size; i++) if (func(arr[i])) result[(*result_size)++] = arr[i]; return result; }",
+"#include <stdlib.h>\nint reduce(int* arr, size_t size, int (*func)(int, int), int initial) { int result = initial; for (size_t i = 0; i < size; i++) result = func(result, arr[i]); return result; }",
+"#include <stdlib.h>\nint* list_comprehension(int* arr, size_t size, int (*func)(int), size_t* result_size) { int* result = malloc(size * sizeof(int)); *result_size = 0; for (size_t i = 0; i < size; i++) result[(*result_size)++] = func(arr[i]); return result; }",
+"#include <stdlib.h>\nint* dict_comprehension(int* keys, int* values, size_t size, int (*func)(int, int), size_t* result_size) { int* result = malloc(size * sizeof(int)); *result_size = 0; for (size_t i = 0; i < size; i++) result[(*result_size)++] = func(keys[i], values[i]); return result; }",
+"#include <stdlib.h>\nint* set_comprehension(int* arr, size_t size, int (*func)(int), size_t* result_size) { int* result = malloc(size * sizeof(int)); *result_size = 0; for (size_t i = 0; i < size; i++) result[(*result_size)++] = func(arr[i]); return result; }",
+"#include <stdlib.h>\nint* set_intersection(int* set1, int* set2, size_t size1, size_t size2, size_t* result_size) { int* result = malloc((size1 < size2 ? size1 : size2) * sizeof(int)); *result_size = 0; for (size_t i = 0; i < size1; i++) for (size_t j = 0; j < size2; j++) if (set1[i] == set2[j]) result[(*result_size)++] = set1[i]; return result; }",
+"#include <stdlib.h>\nint* set_union(int* set1, int* set2, size_t size1, size_t size2, size_t* result_size) { int* result = malloc((size1 + size2) * sizeof(int)); *result_size = 0; for (size_t i = 0; i < size1; i++) result[(*result_size)++] = set1[i]; for (size_t j = 0; j < size2; j++) { int found = 0; for (size_t i = 0; i < size1; i++) if (set2[j] == set1[i]) { found = 1; break; } if (!found) result[(*result_size)++] = set2[j]; } return result; }",
+"#include <stdlib.h>\nint* set_difference(int* set1, int* set2, size_t size1, size_t size2, size_t* result_size) { int* result = malloc(size1 * sizeof(int)); *result_size = 0; for (size_t i = 0; i < size1; i++) { int found = 0; for (size_t j = 0; j < size2; j++) if (set1[i] == set2[j]) { found = 1; break; } if (!found) result[(*result_size)++] = set1[i]; } return result; }",
+"#include <stdlib.h>\nint* remove_none_values(int* arr, size_t size, size_t* result_size) { int* result = malloc(size * sizeof(int)); *result_size = 0; for (size_t i = 0; i < size; i++) if (arr[i] != 0) result[(*result_size)++] = arr[i]; return result; }",
+"#include <stdio.h>\n#define TRY_OPEN_FILE(file) if ((file = fopen(\"filename\", \"r\")) == NULL) { perror(\"Error opening file\"); } else",
+"#include <stdio.h>\n#define CHECK_TYPE(var, type) _Generic((var), type: 1, default: 0)",
+"#include <stdbool.h>\nbool str_to_bool(const char* str) { return strcmp(str, \"true\") == 0 || strcmp(str, \"1\") == 0; }",
+"#define IF(condition) if (condition)",
+"#define WHILE(condition) while (condition)",
+"#define FOR_LIST(list, size, i) for (size_t i = 0; i < size; i++)",
+"#define FOR_DICT(dict, size, i) for (size_t i = 0; i < size; i++)",
+"#define FOR_STRING(str, i) for (size_t i = 0; i < strlen(str); i++)",
+"#define BREAK break",
+"#define CONTINUE continue",
+"#define DEFINE_FUNC(name, return_type, ...) return_type name(__VA_ARGS__)",
+"#define DEFAULT_ARG(arg, value) arg = value",
+"#define RETURN_MULTIPLE(...) { __VA_ARGS__ }",
+"#define VARARGS(...) __VA_ARGS__",
+"#define KEYWORD_ARGS(...) __VA_ARGS__",
+"#include <time.h>\n#define TIME_FUNC(func, ...) { clock_t start = clock(); func(__VA_ARGS__); printf(\"Time: %f\\n\", (double)(clock() - start) / CLOCKS_PER_SEC); }",
+"#define DECORATE(func, decorator) decorator(func)",
+"#include <stdlib.h>\n#define CACHE_FUNC(func, ...) { static int cached_result = 0; if (!cached_result) cached_result = func(__VA_ARGS__); return cached_result; }",
+"#define CREATE_GENERATOR(name, type) type name() { static type state = 0; return state++; }",
+"#define YIELD(value) return value",
+"#define NEXT(generator) generator()",
+"#define CREATE_ITERATOR(name, type) type name() { static type state = 0; return state++; }",
+"#define MANUAL_ITERATE(iterator) iterator()",
+"#define ENUMERATE(list, size, i) for (size_t i = 0; i < size; i++)",
+"#include <stdlib.h>\nint* zip(int* list1, int* list2, size_t size, size_t* result_size) { int* result = malloc(size * sizeof(int)); *result_size = 0; for (size_t i = 0; i < size; i++) result[(*result_size)++] = list1[i] + list2[i]; return result; }",
+"#include <stdlib.h>\nint* list_to_dict(int* keys, int* values, size_t size, size_t* result_size) { int* result = malloc(size * sizeof(int)); *result_size = 0; for (size_t i = 0; i < size; i++) result[(*result_size)++] = values[i]; return result; }",
+"#define EQUAL_LISTS(list1, list2, size) memcmp(list1, list2, size) == 0",
+"#define EQUAL_DICTS(dict1, dict2, size) memcmp(dict1, dict2, size) == 0",
+"#define EQUAL_SETS(set1, set2, size) memcmp(set1, set2, size) == 0",
+"#include <stdlib.h>\nint* set_unique(int* set, size_t size, size_t* result_size) { int* result = malloc(size * sizeof(int)); *result_size = 0; for (size_t i = 0; i < size; i++) { int found = 0; for (size_t j = 0; j < *result_size; j++) if (set[i] == result[j]) { found = 1; break; } if (!found) result[(*result_size)++] = set[i]; } return result; }",
+"#define CLEAR_SET(set, size) memset(set, 0, size * sizeof(int))",
+"#define IS_SET_EMPTY(set, size) size == 0",
+"#define ADD_TO_SET(set, size, value) set[size++] = value",
+"#define REMOVE_FROM_SET(set, size, value) { for (size_t i = 0; i < size; i++) if (set[i] == value) { set[i] = set[--size]; break; } }",
+"#define SET_CONTAINS(set, size, value) ({ int found = 0; for (size_t i = 0; i < size; i++) if (set[i] == value) { found = 1; break; } found; })",
+"#define SET_SIZE(set, size) size",
+"#define SETS_INTERSECT(set1, set2, size1, size2) ({ int found = 0; for (size_t i = 0; i < size1; i++) for (size_t j = 0; j < size2; j++) if (set1[i] == set2[j]) { found = 1; break; } found; })",
+"#define IS_SUBSET(list1, list2, size1, size2) ({ int found = 1; for (size_t i = 0; i < size1; i++) { int match = 0; for (size_t j = 0; j < size2; j++) if (list1[i] == list2[j]) { match = 1; break; } if (!match) { found = 0; break; } } found; })",
+"#define IS_SUBSTRING(str, substr) strstr(str, substr) != NULL",
+"#define FIRST_CHAR(str) str[0]",
+"#define LAST_CHAR(str) str[strlen(str) - 1]",
+"#include <stdio.h>\n#define IS_TEXT_FILE(file) fgetc(file) != EOF",
+"#include <stdio.h>\n#define IS_IMAGE_FILE(file) fgetc(file) != EOF",
+"#include <math.h>\n#define ROUND(num) round(num)",
+"#include <math.h>\n#define CEIL(num) ceil(num)",
+"#include <math.h>\n#define FLOOR(num) floor(num)",
+"#include <stdio.h>\n#define FORMAT_DECIMAL(num, places) printf(\"%.*f\", places, num)",
+"#include <stdlib.h>\n#define RANDOM_STRING(length) ({ char* str = malloc(length + 1); for (size_t i = 0; i < length; i++) str[i] = 'a' + rand() % 26; str[length] = '\\0'; str; })",
+"#include <unistd.h>\n#define PATH_EXISTS(path) access(path, F_OK) == 0",
+"#include <dirent.h>\n#define LIST_DIRECTORY(dir) ({ DIR* d = opendir(dir); struct dirent* entry; while ((entry = readdir(d)) != NULL) printf(\"%s\\n\", entry->d_name); closedir(d); })",
+"#include <libgen.h>\n#define GET_EXTENSION(path) strrchr(path, '.')",
+"#include <libgen.h>\n#define GET_FILENAME(path) basename(path)",
+"#include <libgen.h>\n#define GET_FULL_PATH(path) realpath(path, NULL)",
+"#include <Python.h>\n#define PYTHON_VERSION Py_GetVersion()",
+"#include <sys/utsname.h>\n#define SYSTEM_INFO ({ struct utsname info; uname(&info); info.sysname; })",
+"#include <unistd.h>\n#define CPU_CORES sysconf(_SC_NPROCESSORS_ONLN)",
+"#include <sys/sysinfo.h>\n#define MEMORY_SIZE ({ struct sysinfo info; sysinfo(&info); info.totalram; })",
+"#include <sys/statvfs.h>\n#define DISK_USAGE(path) ({ struct statvfs info; statvfs(path, &info); (info.f_blocks - info.f_bfree) * info.f_frsize; })",
+"#include <ifaddrs.h>\n#define NETWORK_IP ({ struct ifaddrs* ifaddr; getifaddrs(&ifaddr); ifaddr->ifa_addr; })",
+"#include <unistd.h>\n#define IS_CONNECTED system(\"ping -c 1 google.com\") == 0",
+"#include <curl/curl.h>\n#define DOWNLOAD_FILE(url, file) ({ CURL* curl = curl_easy_init(); curl_easy_setopt(curl, CURLOPT_URL, url); curl_easy_setopt(curl, CURLOPT_WRITEDATA, fopen(file, \"wb\")); curl_easy_perform(curl); curl_easy_cleanup(curl); })",
+"#include <curl/curl.h>\n#define UPLOAD_FILE(url, file) ({ CURL* curl = curl_easy_init(); curl_easy_setopt(curl, CURLOPT_URL, url); curl_easy_setopt(curl, CURLOPT_READDATA, fopen(file, \"rb\")); curl_easy_perform(curl); curl_easy_cleanup(curl); })",
+"#include <curl/curl.h>\n#define POST_REQUEST(url, data) ({ CURL* curl = curl_easy_init(); curl_easy_setopt(curl, CURLOPT_URL, url); curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data); curl_easy_perform(curl); curl_easy_cleanup(curl); })",
+"#include <curl/curl.h>\n#define SEND_REQUEST(url, params) ({ CURL* curl = curl_easy_init(); curl_easy_setopt(curl, CURLOPT_URL, url); curl_easy_setopt(curl, CURLOPT_POSTFIELDS, params); curl_easy_perform(curl); curl_easy_cleanup(curl); })",
+"#include <curl/curl.h>\n#define SET_HEADERS(curl, headers) curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers)",
+"#include <libxml/HTMLparser.h>\n#define PARSE_HTML(html) ({ htmlDocPtr doc = htmlReadDoc((xmlChar*)html, NULL, NULL, HTML_PARSE_RECOVER | HTML_PARSE_NOERROR | HTML_PARSE_NOWARNING); doc; })",
+"#include <libxml/HTMLparser.h>\n#define EXTRACT_TITLE(doc) ({ xmlChar* title = xmlNodeGetContent(xmlDocGetRootElement(doc)->children); title; })",
+"#include <libxml/HTMLparser.h>\n#define EXTRACT_LINKS(doc) ({ xmlNodePtr cur = xmlDocGetRootElement(doc)->children; while (cur != NULL) { if (cur->type == XML_ELEMENT_NODE && xmlStrcmp(cur->name, (xmlChar*)\"a\") == 0) printf(\"%s\\n\", xmlGetProp(cur, (xmlChar*)\"href\")); cur = cur->next; } })",
+"#include <libxml/HTMLparser.h>\n#define DOWNLOAD_IMAGES(doc) ({ xmlNodePtr cur = xmlDocGetRootElement(doc)->children; while (cur != NULL) { if (cur->type == XML_ELEMENT_NODE && xmlStrcmp(cur->name, (xmlChar*)\"img\") == 0) printf(\"%s\\n\", xmlGetProp(cur, (xmlChar*)\"src\")); cur = cur->next; } })",
+"#include <libxml/HTMLparser.h>\n#define COUNT_WORDS(doc) ({ xmlNodePtr cur = xmlDocGetRootElement(doc)->children; int count = 0; while (cur != NULL) { if (cur->type == XML_TEXT_NODE) count += xmlStrlen(cur->content); cur = cur->next; } count; })",
+"#include <libxml/HTMLparser.h>\n#define SIMULATE_LOGIN(doc, username, password) ({ xmlNodePtr cur = xmlDocGetRootElement(doc)->children; while (cur != NULL) { if (cur->type == XML_ELEMENT_NODE && xmlStrcmp(cur->name, (xmlChar*)\"form\") == 0) printf(\"%s\\n\", xmlGetProp(cur, (xmlChar*)\"action\")); cur = cur->next; } })",  
+"#include <libxml/HTMLparser.h>\n#define HTML_TO_TEXT(doc) ({ xmlChar* text = xmlNodeGetContent(xmlDocGetRootElement(doc)); text; })",  
+"#include <regex.h>\n#define EXTRACT_EMAIL(str) ({ regex_t regex; regcomp(&regex, \"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}\", REG_EXTENDED); regmatch_t match; regexec(&regex, str, 1, &match, 0); strndup(str + match.rm_so, match.rm_eo - match.rm_so); })",  
+"#include <regex.h>\n#define EXTRACT_PHONE(str) ({ regex_t regex; regcomp(&regex, \"\\\\+?[0-9]{10,13}\", REG_EXTENDED); regmatch_t match; regexec(&regex, str, 1, &match, 0); strndup(str + match.rm_so, match.rm_eo - match.rm_so); })",  
+"#include <regex.h>\n#define FIND_ALL_NUMBERS(str) ({ regex_t regex; regcomp(&regex, \"[0-9]+\", REG_EXTENDED); regmatch_t match; char* result = str; while (regexec(&regex, result, 1, &match, 0) == 0) { printf(\"%s\\n\", strndup(result + match.rm_so, match.rm_eo - match.rm_so)); result += match.rm_eo; } })",  
+"#include <regex.h>\n#define REGEX_REPLACE(str, pattern, replacement) ({ regex_t regex; regcomp(&regex, pattern, REG_EXTENDED); regmatch_t match; char* result = str; while (regexec(&regex, result, 1, &match, 0) == 0) { printf(\"%s%s\", strndup(result, match.rm_so), replacement); result += match.rm_eo; } printf(\"%s\\n\", result); })",  
+"#include <regex.h>\n#define MATCH_REGEX(str, pattern) ({ regex_t regex; regcomp(&regex, pattern, REG_EXTENDED); regexec(&regex, str, 0, NULL, 0) == 0; })",  
+"#include <libxml/HTMLparser.h>\n#define REMOVE_HTML_TAGS(html) ({ xmlChar* text = xmlNodeGetContent(xmlDocGetRootElement(htmlReadDoc((xmlChar*)html, NULL, NULL, HTML_PARSE_RECOVER | HTML_PARSE_NOERROR | HTML_PARSE_NOWARNING))); text; })",  
+"#include <libxml/HTMLparser.h>\n#define HTML_ENCODE(str) ({ xmlChar* encoded = xmlEncodeEntitiesReentrant(NULL, (xmlChar*)str); encoded; })",  
+"#include <libxml/HTMLparser.h>\n#define HTML_DECODE(str) ({ xmlChar* decoded = xmlDecodeEntitiesReentrant(NULL, (xmlChar*)str, XML_SUBSTITUTE_REF); decoded; })",  
+"#include <gtk/gtk.h>\n#define CREATE_GUI_WINDOW() ({ gtk_init(NULL, NULL); GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_widget_show_all(window); gtk_main(); })",
+"void add_button_to_window(GtkWidget *window, const char *label) { GtkWidget *button = gtk_button_new_with_label(label); gtk_container_add(GTK_CONTAINER(window), button); }",
+"void on_button_clicked(GtkWidget *widget, gpointer data) { g_print(\"Button clicked\\n\"); }",
+"void show_message_dialog(GtkWidget *window, const char *message) { GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, message); gtk_dialog_run(GTK_DIALOG(dialog)); gtk_widget_destroy(dialog); }",
+"const char *get_entry_text(GtkWidget *entry) { return gtk_entry_get_text(GTK_ENTRY(entry)); }",
+"void set_window_title(GtkWidget *window, const char *title) { gtk_window_set_title(GTK_WINDOW(window), title); }",
+"void set_window_size(GtkWidget *window, int width, int height) { gtk_window_set_default_size(GTK_WINDOW(window), width, height); }",
+"void center_window(GtkWidget *window) { gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER); }",
+"GtkWidget *create_menu_bar() { return gtk_menu_bar_new(); }",
+"GtkWidget *create_combo_box() { return gtk_combo_box_text_new(); }",
+"GtkWidget *create_radio_button() { return gtk_radio_button_new(NULL); }",
+"GtkWidget *create_check_button() { return gtk_check_button_new(); }",
+"void show_image(GtkWidget *window, const char *file_path) { GtkWidget *image = gtk_image_new_from_file(file_path); gtk_container_add(GTK_CONTAINER(window), image); }",
+"void play_audio(const char *file_path) { GstElement *pipeline = gst_parse_launch(\"playbin uri=file://\" file_path, NULL); gst_element_set_state(pipeline, GST_STATE_PLAYING); }",
+"void play_video(const char *file_path) { GstElement *pipeline = gst_parse_launch(\"playbin uri=file://\" file_path, NULL); gst_element_set_state(pipeline, GST_STATE_PLAYING); }",
+"gint64 get_current_play_time(GstElement *pipeline) { gint64 current_time; gst_element_query_position(pipeline, GST_FORMAT_TIME, &current_time); return current_time; }",
+"void capture_screen() { Display *display = XOpenDisplay(NULL); Window root = DefaultRootWindow(display); XImage *image = XGetImage(display, root, 0, 0, DisplayWidth(display, 0), DisplayHeight(display, 0), AllPlanes, ZPixmap); XCloseDisplay(display); }",
+"void record_screen(int duration) { /* Implementation for screen recording */ }",
+"void get_mouse_position(int *x, int *y) { Display *display = XOpenDisplay(NULL); Window root = DefaultRootWindow(display); Window child; int root_x, root_y; XQueryPointer(display, root, &root, &child, x, y, &root_x, &root_y, NULL); XCloseDisplay(display); }",
+"void simulate_keyboard_input(const char *text) { /* Implementation for keyboard input simulation */ }",
+"void simulate_mouse_click(int x, int y) { /* Implementation for mouse click simulation */ }",
+"time_t get_current_timestamp() { return time(NULL); }",
+"char *timestamp_to_date(time_t timestamp) { return ctime(&timestamp); }",
+"time_t date_to_timestamp(const char *date) { struct tm tm; strptime(date, \"%Y-%m-%d %H:%M:%S\", &tm); return mktime(&tm); }",
+"int get_current_weekday() { time_t now = time(NULL); struct tm *tm = localtime(&now); return tm->tm_wday; }",
+"int get_days_in_month(int year, int month) { struct tm tm = {0, 0, 0, 0, month - 1, year - 1900}; return 31 - ((mktime(&tm) / 86400) % 31); }",
+"time_t get_first_day_of_year(int year) { struct tm tm = {0, 0, 0, 1, 0, year - 1900}; return mktime(&tm); }",
+"time_t get_last_day_of_year(int year) { struct tm tm = {0, 0, 0, 31, 11, year - 1900}; return mktime(&tm); }",
+"time_t get_first_day_of_month(int year, int month) { struct tm tm = {0, 0, 0, 1, month - 1, year - 1900}; return mktime(&tm); }",
+"time_t get_last_day_of_month(int year, int month) { struct tm tm = {0, 0, 0, 0, month, year - 1900}; tm.tm_mday -= 1; return mktime(&tm); }",
+"int is_weekday(time_t timestamp) { struct tm *tm = localtime(&timestamp); return tm->tm_wday >= 1 && tm->tm_wday <= 5; }",
+"int is_weekend(time_t timestamp) { struct tm *tm = localtime(&timestamp); return tm->tm_wday == 0 || tm->tm_wday == 6; }",
+"int get_current_hour() { time_t now = time(NULL); struct tm *tm = localtime(&now); return tm->tm_hour; }",
+"int get_current_minute() { time_t now = time(NULL); struct tm *tm = localtime(&now); return tm->tm_min; }",
+"int get_current_second() { time_t now = time(NULL); struct tm *tm = localtime(&now); return tm->tm_sec; }",
+"void sleep_one_second() { sleep(1); }",
+"long get_millisecond_timestamp() { struct timeval tv; gettimeofday(&tv, NULL); return tv.tv_sec * 1000 + tv.tv_usec / 1000; }",
+"char *format_time(time_t timestamp, const char *format) { struct tm *tm = localtime(&timestamp); static char buffer[80]; strftime(buffer, 80, format, tm); return buffer; }",
+"time_t parse_time(const char *time_str, const char *format) { struct tm tm; strptime(time_str, format, &tm); return mktime(&tm); }",
+"void *thread_function(void *arg) { /* Implementation for thread function */ return NULL; }",
+"void create_thread() { pthread_t thread; pthread_create(&thread, NULL, thread_function, NULL); }",
+"void pause_thread(pthread_t thread) { pthread_kill(thread, SIGSTOP); }",
+"void run_function_in_thread(void *(*function)(void *), void *arg) { pthread_t thread; pthread_create(&thread, NULL, function, arg); }",
+"char *get_current_thread_name() { static char name[16]; pthread_getname_np(pthread_self(), name, 16); return name; }",
+"void set_thread_as_daemon(pthread_t thread) { pthread_detach(thread); }",
+"pthread_mutex_t lock;",
+"void lock_thread() { pthread_mutex_lock(&lock); }",
+"void unlock_thread() { pthread_mutex_unlock(&lock); }",
+"void create_process() { pid_t pid = fork(); if (pid == 0) { /* Child process */ } else { /* Parent process */ } }",
+"pid_t get_process_pid() { return getpid(); }",
+"int is_process_alive(pid_t pid) { return kill(pid, 0) == 0; }",
+"void run_function_in_process(void (*function)()) { pid_t pid = fork(); if (pid == 0) { function(); exit(0); } }",
+"void send_message_to_queue(int msgid, const void *msg, size_t size) { msgsnd(msgid, msg, size, 0); }",
+"void receive_message_from_queue(int msgid, void *msg, size_t size, long type) { msgrcv(msgid, msg, size, type, 0); }",
+"void pipe_communication() { int fd[2]; pipe(fd); if (fork() == 0) { close(fd[0]); write(fd[1], \"Hello\", 6); close(fd[1]); } else { close(fd[1]); char buffer[6]; read(fd[0], buffer, 6); close(fd[0]); } }",
+"void limit_cpu_usage(int percentage) { /* Implementation for CPU usage limiting */ }",
+"void run_shell_command(const char *command) { system(command); }",
+"char *get_command_output(const char *command) { FILE *fp = popen(command, \"r\"); static char buffer[1024]; fgets(buffer, 1024, fp); pclose(fp); return buffer; }",
+"int get_command_status_code(const char *command) { return system(command); }",
+"int is_command_successful(const char *command) { return system(command) == 0; }",
+"char *get_current_script_path() { static char path[1024]; readlink(\"/proc/self/exe\", path, 1024); return path; }",
+"void parse_arguments(int argc, char *argv[]) { struct argp_option options[] = { {0} }; struct argp argp = {options, NULL, NULL, NULL}; argp_parse(&argp, argc, argv, 0, 0, NULL); }",
+"void generate_help_document() { /* Implementation for help document generation */ }",
+"void list_python_modules() { system(\"python -c 'import sys; print(sys.modules)'\"); }",
+"void install_python_package(const char *package) { system(\"pip install \" package); }",
+"void uninstall_python_package(const char *package) { system(\"pip uninstall \" package); }",
+"char *get_package_version(const char *package) { FILE *fp = popen(\"pip show \" package, \"r\"); static char buffer[1024]; fgets(buffer, 1024, fp); pclose(fp); return buffer; }",
+"void use_virtual_environment(const char *env) { setenv(\"VIRTUAL_ENV\", env, 1); }",
+"void list_installed_packages() { system(\"pip list\"); }",
+"void upgrade_python_package(const char *package) { system(\"pip install --upgrade \" package); }",
+"void connect_to_database(const char *db_name) { sqlite3_open(db_name, &db); }",
+"void execute_sql_query(const char *query) { sqlite3_exec(db, query, NULL, NULL, NULL); }",
+"void insert_record(const char *table, const char *values) { char query[1024]; sprintf(query, \"INSERT INTO %s VALUES (%s)\", table, values); sqlite3_exec(db, query, NULL, NULL, NULL); }",
+"void delete_record(const char *table, const char *condition) { char query[1024]; sprintf(query, \"DELETE FROM %s WHERE %s\", table, condition); sqlite3_exec(db, query, NULL, NULL, NULL); }",
+"void update_record(const char *table, const char *set_clause, const char *condition) { char query[1024]; sprintf(query, \"UPDATE %s SET %s WHERE %s\", table, set_clause, condition); sqlite3_exec(db, query, NULL, NULL, NULL); }",
+"void select_records(const char *table, const char *condition) { char query[1024]; sprintf(query, \"SELECT * FROM %s WHERE %s\", table, condition); sqlite3_exec(db, query, NULL, NULL, NULL); }",
+"void use_parameterized_query(const char *query, const char *params) { sqlite3_stmt *stmt; sqlite3_prepare_v2(db, query, -1, &stmt, NULL); sqlite3_bind_text(stmt, 1, params, -1, SQLITE_STATIC); sqlite3_step(stmt); sqlite3_finalize(stmt); }",
+"void close_database_connection() { sqlite3_close(db); }",
+"void create_table(const char *table, const char *columns) { char query[1024]; sprintf(query, \"CREATE TABLE %s (%s)\", table, columns); sqlite3_exec(db, query, NULL, NULL, NULL); }",
+"void drop_table(const char *table) { char query[1024]; sprintf(query, \"DROP TABLE %s\", table); sqlite3_exec(db, query, NULL, NULL, NULL); }",
+"int is_table_exists(const char *table) { char query[1024]; sprintf(query, \"SELECT name FROM sqlite_master WHERE type='table' AND name='%s'\", table); sqlite3_stmt *stmt; sqlite3_prepare_v2(db, query, -1, &stmt, NULL); int result = sqlite3_step(stmt); sqlite3_finalize(stmt); return result == SQLITE_ROW; }",
+"void list_all_tables() { sqlite3_exec(db, \"SELECT name FROM sqlite_master WHERE type='table'\", NULL, NULL, NULL); }",
+"void orm_insert_data(const char *table, const char *values) { char query[1024]; sprintf(query, \"INSERT INTO %s VALUES (%s)\", table, values); sqlite3_exec(db, query, NULL, NULL, NULL); }",
+"void orm_select_data(const char *table, const char *condition) { char query[1024]; sprintf(query, \"SELECT * FROM %s WHERE %s\", table, condition); sqlite3_exec(db, query, NULL, NULL, NULL); }",
+"void orm_delete_data(const char *table, const char *condition) { char query[1024]; sprintf(query, \"DELETE FROM %s WHERE %s\", table, condition); sqlite3_exec(db, query, NULL, NULL, NULL); }",
+"void orm_update_data(const char *table, const char *set_clause, const char *condition) { char query[1024]; sprintf(query, \"UPDATE %s SET %s WHERE %s\", table, set_clause, condition); sqlite3_exec(db, query, NULL, NULL, NULL); }",
+"void define_model_class(const char *name, const char *fields) { /* Implementation for model class definition */ }",
+"void implement_model_inheritance(const char *base_class, const char *derived_class) { /* Implementation for model inheritance */ }",
+"void set_primary_key(const char *table, const char *field) { char query[1024]; sprintf(query, \"ALTER TABLE %s ADD PRIMARY KEY (%s)\", table, field); sqlite3_exec(db, query, NULL, NULL, NULL); }",
+"void set_unique_constraint(const char *table, const char *field) { char query[1024]; sprintf(query, \"ALTER TABLE %s ADD UNIQUE (%s)\", table, field); sqlite3_exec(db, query, NULL, NULL, NULL); }",
+"void set_field_default_value(const char *table, const char *field, const char *default_value) { char query[1024]; sprintf(query, \"ALTER TABLE %s ALTER COLUMN %s SET DEFAULT %s\", table, field, default_value); sqlite3_exec(db, query, NULL, NULL, NULL); }",
+"void export_data_to_csv(const char *table, const char *file_path) { char query[1024]; sprintf(query, \".mode csv\\n.output %s\\nSELECT * FROM %s\", file_path, table); sqlite3_exec(db, query, NULL, NULL, NULL); }",
+"void export_data_to_excel(const char *table, const char *file_path) { /* Implementation for Excel export */ }",
+"void export_data_to_json(const char *table, const char *file_path) { /* Implementation for JSON export */ }",
+"void read_excel_data(const char *file_path) { /* Implementation for Excel data reading */ }",
+"void merge_excel_files(const char *file1, const char *file2, const char *output_file) { /* Implementation for Excel file merging */ }",
+"void add_sheet_to_excel(const char *file_path, const char *sheet_name) { /* Implementation for adding sheet to Excel */ }",
+"void copy_excel_sheet_style(const char *source_file, const char *target_file) { /* Implementation for copying Excel sheet style */ }",
+"void set_excel_cell_color(const char *file_path, const char *sheet, int row, int col, const char *color) { /* Implementation for setting Excel cell color */ }",
+"void set_excel_font_style(const char *file_path, const char *sheet, int row, int col, const char *style) { /* Implementation for setting Excel font style */ }",
+"void read_excel_cell_content(const char *file_path, const char *sheet, int row, int col) { /* Implementation for reading Excel cell content */ }",
+"void write_excel_cell_content(const char *file_path, const char *sheet, int row, int col, const char *content) { /* Implementation for writing Excel cell content */ }",
+"void get_image_dimensions(const char *file_path, int *width, int *height) { /* Implementation for getting image dimensions */ }",
+"void resize_image(const char *file_path, int new_width, int new_height) { /* Implementation for resizing image */ }"