Update app.py

app.py

@@ -14,449 +14,306 @@ app.logger = logging.getLogger("CodeSearchAPI")
 # 预定义代码片段
 CODE_SNIPPETS = [
 
-"public static void PrintText(string text) => Console.WriteLine(text)",  
-"public static int Sum(int a, int b) => a + b",  
-"public static int GenerateRandomNumber() => new Random().Next()",  
-"public static bool IsEven(int number) => number % 2 == 0",  
-"public static int GetStringLength(string str) => str.Length",  
-"public static DateTime GetCurrentDate() => DateTime.Today",  
-"public static bool FileExists(string path) => File.Exists(path)",  
-"public static string ReadFileContent(string path) => File.ReadAllText(path)",  
-"public static void WriteToFile(string path, string content) => File.WriteAllText(path, content)",  
-"public static DateTime GetCurrentTime() => DateTime.Now",  
-"public static string ToUpperCase(string str) => str.ToUpper()",  
-"public static string ToLowerCase(string str) => str.ToLower()",  
-"public static string ReverseString(string str) => new string(str.Reverse().ToArray())",  
-"public static int CountListElements<T>(List<T> list) => list.Count",  
-"public static T GetMaxValue<T>(List<T> list) where T : IComparable => list.Max()",  
-"public static T GetMinValue<T>(List<T> list) where T : IComparable => list.Min()",  
-"public static List<T> SortList<T>(List<T> list) where T : IComparable => list.OrderBy(x => x).ToList()",  
-"public static List<T> MergeLists<T>(List<T> list1, List<T> list2) => list1.Concat(list2).ToList()",  
-"public static List<T> RemoveElement<T>(List<T> list, T element) => list.Where(x => !x.Equals(element)).ToList()",  
-"public static bool IsListEmpty<T>(List<T> list) => list.Count == 0",  
-"public static int CountCharInString(string str, char c) => str.Count(x => x == c)",  
-"public static bool ContainsSubstring(string str, string substring) => str.Contains(substring)",  
-"public static string NumberToString(int number) => number.ToString()",  
-"public static int StringToNumber(string str) => int.Parse(str)",  
-"public static bool IsNumeric(string str) => int.TryParse(str, out _)",  
-"public static int GetElementIndex<T>(List<T> list, T element) => list.IndexOf(element)",  
-"public static void ClearList<T>(List<T> list) => list.Clear()",  
-"public static List<T> ReverseList<T>(List<T> list) { list.Reverse(); return list; }",  
-"public static List<T> RemoveDuplicates<T>(List<T> list) => list.Distinct().ToList()",  
-"public static bool IsInList<T>(List<T> list, T value) => list.Contains(value)",  
-"public static Dictionary<TKey, TValue> CreateDictionary<TKey, TValue>() => new Dictionary<TKey, TValue>()",  
-"public static void AddToDictionary<TKey, TValue>(Dictionary<TKey, TValue> dict, TKey key, TValue value) => dict[key] = value",  
-"public static void RemoveKey<TKey, TValue>(Dictionary<TKey, TValue> dict, TKey key) => dict.Remove(key)",  
-"public static List<TKey> GetDictionaryKeys<TKey, TValue>(Dictionary<TKey, TValue> dict) => dict.Keys.ToList()",  
-"public static List<TValue> GetDictionaryValues<TKey, TValue>(Dictionary<TKey, TValue> dict) => dict.Values.ToList()",  
-"public static Dictionary<TKey, TValue> MergeDictionaries<TKey, TValue>(Dictionary<TKey, TValue> dict1, Dictionary<TKey, TValue> dict2) => dict1.Concat(dict2).ToDictionary(x => x.Key, x => x.Value)",  
-"public static bool IsDictionaryEmpty<TKey, TValue>(Dictionary<TKey, TValue> dict) => dict.Count == 0",  
-"public static TValue GetDictionaryValue<TKey, TValue>(Dictionary<TKey, TValue> dict, TKey key) => dict[key]",  
-"public static bool KeyExistsInDictionary<TKey, TValue>(Dictionary<TKey, TValue> dict, TKey key) => dict.ContainsKey(key)",  
-"public static void ClearDictionary<TKey, TValue>(Dictionary<TKey, TValue> dict) => dict.Clear()",  
-"public static int CountFileLines(string path) => File.ReadAllLines(path).Length",  
-"public static void WriteListToFile<T>(string path, List<T> list) => File.WriteAllLines(path, list.Select(x => x.ToString()))",  
-"public static List<T> ReadListFromFile<T>(string path, Func<string, T> converter) => File.ReadAllLines(path).Select(converter).ToList()",  
-"public static int CountFileWords(string path) => File.ReadAllText(path).Split(new[] { ' ', '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries).Length",  
-"public static bool IsLeapYear(int year) => DateTime.IsLeapYear(year)",  
-"public static string FormatDateTime(DateTime dateTime, string format) => dateTime.ToString(format)",  
-"public static int DaysBetweenDates(DateTime date1, DateTime date2) => (date2 - date1).Days",  
-"public static string GetCurrentDirectory() => Directory.GetCurrentDirectory()",  
-"public static List<string> ListDirectoryFiles(string path) => Directory.GetFiles(path).ToList()",  
-"public static void CreateDirectory(string path) => Directory.CreateDirectory(path)",  
-"public static void DeleteDirectory(string path) => Directory.Delete(path)",  
-"public static bool IsFilePath(string path) => File.Exists(path)",  
-"public static bool IsDirectoryPath(string path) => Directory.Exists(path)",  
-"public static long GetFileSize(string path) => new FileInfo(path).Length",  
-"public static void RenameFile(string oldPath, string newPath) => File.Move(oldPath, newPath)",  
-"public static void CopyFile(string sourcePath, string destinationPath) => File.Copy(sourcePath, destinationPath)",  
-"public static void MoveFile(string sourcePath, string destinationPath) => File.Move(sourcePath, destinationPath)",  
-"public static void DeleteFile(string path) => File.Delete(path)",  
-"public static string GetEnvironmentVariable(string variable) => Environment.GetEnvironmentVariable(variable)",  
-"public static void SetEnvironmentVariable(string variable, string value) => Environment.SetEnvironmentVariable(variable, value)",  
-"public static void OpenWebLink(string url) => System.Diagnostics.Process.Start(url)",  
-"public static string SendGetRequest(string url) => new System.Net.WebClient().DownloadString(url)",  
-"public static T ParseJson<T>(string json) => System.Text.Json.JsonSerializer.Deserialize<T>(json)",  
-"public static void WriteJsonToFile<T>(string path, T data) => File.WriteAllText(path, System.Text.Json.JsonSerializer.Serialize(data))",  
-"public static T ReadJsonFromFile<T>(string path) => System.Text.Json.JsonSerializer.Deserialize<T>(File.ReadAllText(path))",  
-"public static string ListToString<T>(List<T> list) => string.Join("", list)",  
-"public static List<string> StringToList(string str) => str.ToCharArray().Select(c => c.ToString()).ToList()",  
-"public static string JoinListWithComma<T>(List<T> list) => string.Join(",", list)",  
-"public static string JoinListWithNewLine<T>(List<T> list) => string.Join(\"\n\", list)",  
-"public static List<string> SplitStringBySpace(string str) => str.Split(' ').ToList()",  
-"public static List<string> SplitStringByDelimiter(string str, char delimiter) => str.Split(delimiter).ToList()",  
-"public static List<char> SplitStringToChars(string str) => str.ToCharArray().ToList()",  
-"public static string ReplaceStringContent(string str, string oldValue, string newValue) => str.Replace(oldValue, newValue)",  
-"public static string RemoveStringSpaces(string str) => str.Replace(" ", "")",  
-"public static string RemoveStringPunctuation(string str) => new string(str.Where(c => !char.IsPunctuation(c)).ToArray())",  
-"public static bool IsStringEmpty(string str) => string.IsNullOrEmpty(str)",  
-"public static bool IsPalindrome(string str) => str.SequenceEqual(str.Reverse())",  
-"public static void WriteTextToCsv(string path, List<string> lines) => File.WriteAllLines(path, lines)",  
-"public static List<string> ReadCsvFile(string path) => File.ReadAllLines(path).ToList()",  
-"public static int CountCsvLines(string path) => File.ReadAllLines(path).Length",  
-"public static List<T> ShuffleList<T>(List<T> list) => list.OrderBy(x => Guid.NewGuid()).ToList()",  
-"public static T GetRandomElement<T>(List<T> list) => list[new Random().Next(list.Count)]",  
-"public static List<T> GetRandomElements<T>(List<T> list, int count) => list.OrderBy(x => Guid.NewGuid()).Take(count).ToList()",  
-"public static int RollDice() => new Random().Next(1, 7)",  
-"public static string FlipCoin() => new Random().Next(2) == 0 ? \"Heads\" : \"Tails\"",  
-"public static string GenerateRandomPassword(int length) => new string(Enumerable.Repeat(\"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789\", length).Select(s => s[new Random().Next(s.Length)]).ToArray())",  
-"public static string GenerateRandomColor() => string.Format(\"#{0:X6}\", new Random().Next(0x1000000))",  
-"public static string GenerateUniqueId() => Guid.NewGuid().ToString()",  
-"public class MyClass { }",  
-"public static MyClass CreateClassInstance() => new MyClass()",  
-"public class MyClass { public void MyMethod() { } }",  
-"public class MyClass { public string MyProperty { get; set; } }",  
-"public class ChildClass : MyClass { }",  
-"public class ChildClass : MyClass { public override void MyMethod() { } }",  
-"public static void UseClassMethod(MyClass obj) => obj.MyMethod()",  
-"public class MyClass { public static void StaticMethod() { } }",  
-"public static bool IsObjectType<T>(object obj) => obj is T",  
-"public static object GetObjectProperty(object obj, string propertyName) => obj.GetType().GetProperty(propertyName).GetValue(obj)",  
-"public static void SetObjectProperty(object obj, string propertyName, object value) => obj.GetType().GetProperty(propertyName).SetValue(obj, value)",  
-"public static void DeleteObjectProperty(object obj, string propertyName) => obj.GetType().GetProperty(propertyName).SetValue(obj, null)",
-"""
-public static void TryCatchExample()
-{
-    try { throw new Exception("Example exception"); }
-    catch (Exception ex) { Console.WriteLine(ex.Message); }
-}
-""",
-"""
-public static void ThrowCustomException() => throw new CustomException("Custom exception"),
-""",
-"""
-public static string GetExceptionInfo(Exception ex) => ex.Message,
-""",
-"""
-public static void LogError(Exception ex) => Console.WriteLine($"Error: {ex.Message}"),
-""",
-"""
-public static System.Diagnostics.Stopwatch CreateTimer() => System.Diagnostics.Stopwatch.StartNew(),
-""",
-"""
-public static long GetProgramRuntime(System.Diagnostics.Stopwatch timer) => timer.ElapsedMilliseconds,
-""",
-"""
-public static void PrintProgressBar(int progress, int total)
-{
-    float percentage = (float)progress / total;
-    Console.Write($"\r[{'='.Repeat((int)(percentage * 20))}{' '.Repeat(20 - (int)(percentage * 20))}] {percentage * 100:F2}%");
-}
-""",
-"""
-public static void Delay(int milliseconds) => System.Threading.Thread.Sleep(milliseconds),
-""",
-"""
-public static Func<int, int> LambdaExample = x => x * x,
-""",
-"""
-public static List<int> MapExample(List<int> list, Func<int, int> func) => list.Select(func).ToList(),
-""",
-"""
-public static List<int> FilterExample(List<int> list, Func<int, bool> func) => list.Where(func).ToList(),
-""",
-"""
-public static int ReduceExample(List<int> list, Func<int, int, int> func) => list.Aggregate(func),
-""",
-"""
-public static List<int> ListComprehensionExample(List<int> list) => list.Select(x => x * 2).ToList(),
-""",
-"""
-public static Dictionary<int, int> DictComprehensionExample(List<int> list) => list.ToDictionary(x => x, x => x * 2),
-""",
-"""
-public static HashSet<int> SetComprehensionExample(List<int> list) => new HashSet<int>(list.Select(x => x * 2)),
-""",
-"""
-public static HashSet<T> Intersection<T>(HashSet<T> set1, HashSet<T> set2) => new HashSet<T>(set1.Intersect(set2)),
-""",
-"""
-public static HashSet<T> Union<T>(HashSet<T> set1, HashSet<T> set2) => new HashSet<T>(set1.Union(set2)),
-""",
-"""
-public static HashSet<T> Difference<T>(HashSet<T> set1, HashSet<T> set2) => new HashSet<T>(set1.Except(set2)),
-""",
-"""
-public static List<T> RemoveNulls<T>(List<T> list) => list.Where(x => x != null).ToList(),
-""",
-"""
-public static bool TryOpenFile(string path)
-{
-    try { using (var file = File.OpenRead(path)) return true; }
-    catch { return false; }
-}
-""",
-"""
-public static bool CheckVariableType<T>(object obj) => obj is T,
-""",
-"""
-public static bool StringToBool(string str) => bool.Parse(str),
-""",
-"""
-public static void IfExample(bool condition) { if (condition) Console.WriteLine("True"); },
-""",
-"""
-public static void WhileExample(int count) { while (count-- > 0) Console.WriteLine(count); },
-""",
-"""
-public static void ForEachListExample(List<int> list) { foreach (var item in list) Console.WriteLine(item); },
-""",
-"""
-public static void ForEachDictExample(Dictionary<int, string> dict) { foreach (var kvp in dict) Console.WriteLine($"{kvp.Key}: {kvp.Value}"); },
-""",
-"""
-public static void ForEachStringExample(string str) { foreach (var c in str) Console.WriteLine(c); },
-""",
-"""
-public static void BreakExample(List<int> list)
-{
-    foreach (var item in list) { if (item == 0) break; Console.WriteLine(item); }
-}
-""",
-"""
-public static void ContinueExample(List<int> list)
-{
-    foreach (var item in list) { if (item == 0) continue; Console.WriteLine(item); }
-}
-""",
-"""
-public static void DefineFunction() => Console.WriteLine("Function defined"),
-""",
-"""
-public static void FunctionWithDefault(int a = 10) => Console.WriteLine(a),
-""",
-"""
-public static (int, int) ReturnMultipleValues() => (1, 2),
-""",
-"""
-public static void VariableParams(params int[] numbers) => Console.WriteLine(numbers.Sum()),
-""",
-"""
-public static void KeywordParams(int a, int b) => Console.WriteLine(a + b),
-""",
-"""
-public static void MeasureFunctionTime(Action action)
-{
-    var timer = System.Diagnostics.Stopwatch.StartNew();
-    action();
-    Console.WriteLine($"Time: {timer.ElapsedMilliseconds}ms");
-}
-""",
-"""
-public static void DecorateFunction(Action action) => action(),
-""",
-"""
-public static void CacheFunctionResult(Func<int> func) => func(),
-""",
-"""
-public static IEnumerable<int> CreateGenerator()
-{
-    for (int i = 0; i < 10; i++) yield return i;
-}
-""",
-"""
-public static IEnumerable<int> YieldExample()
-{
-    yield return 1;
-    yield return 2;
-}
-""",
-"""
-public static int NextExample(IEnumerator<int> enumerator) => enumerator.Current,
-""",
-"""
-public static IEnumerator<int> CreateIterator(List<int> list) => list.GetEnumerator(),
-""",
-"""
-public static void ManualIterate(IEnumerator<int> enumerator)
-{
-    while (enumerator.MoveNext()) Console.WriteLine(enumerator.Current);
-}
-""",
-"""
-public static void EnumerateExample(List<int> list)
-{
-    foreach (var (index, value) in list.Select((v, i) => (i, v))) Console.WriteLine($"{index}: {value}");
-}
-""",
-"""
-public static List<(int, int)> ZipExample(List<int> list1, List<int> list2) => list1.Zip(list2, (a, b) => (a, b)).ToList(),
-""",
-"""
-public static Dictionary<int, int> ListsToDict(List<int> keys, List<int> values) => keys.Zip(values, (k, v) => new { k, v }).ToDictionary(x => x.k, x => x.v),
-""",
-"""
-public static bool AreListsEqual(List<int> list1, List<int> list2) => list1.SequenceEqual(list2),
-""",
-"""
-public static bool AreDictsEqual(Dictionary<int, int> dict1, Dictionary<int, int> dict2) => dict1.OrderBy(kvp => kvp.Key).SequenceEqual(dict2.OrderBy(kvp => kvp.Key)),
-""",
-"""
-public static bool AreSetsEqual(HashSet<int> set1, HashSet<int> set2) => set1.SetEquals(set2),
-""",
-"""
-public static HashSet<T> RemoveDuplicatesSet<T>(HashSet<T> set) => new HashSet<T>(set),
-""",
-"""
-public static void ClearSet<T>(HashSet<T> set) => set.Clear(),
-""",
-"""
-public static bool IsSetEmpty<T>(HashSet<T> set) => set.Count == 0,
-""",
-"""
-public static void AddToSet<T>(HashSet<T> set, T item) => set.Add(item),
-""",
-"""
-public static void RemoveFromSet<T>(HashSet<T> set, T item) => set.Remove(item),
-""",
-"""
-public static bool SetContains<T>(HashSet<T> set, T item) => set.Contains(item),
-""",
-"""
-public static int GetSetLength<T>(HashSet<T> set) => set.Count,
-""",
-"""
-public static bool SetsIntersect<T>(HashSet<T> set1, HashSet<T> set2) => set1.Overlaps(set2),
-""",
-"""
-public static bool IsSubset<T>(List<T> list1, List<T> list2) => list1.All(list2.Contains),
-""",
-"""
-public static bool IsSubstring(string str, string substring) => str.Contains(substring),
-""",
-"""
-public static char GetFirstChar(string str) => str[0],
-""",
-"""
-public static char GetLastChar(string str) => str[^1],
-""",
-"""
-public static bool IsTextFile(string path) => Path.GetExtension(path).ToLower() == ".txt",
-""",
-"""
-public static bool IsImageFile(string path) => new[] { ".jpg", ".png", ".gif" }.Contains(Path.GetExtension(path).ToLower()),
-""",
-"""
-public static double RoundNumber(double number) => Math.Round(number),
-""",
-"""
-public static double CeilNumber(double number) => Math.Ceiling(number),
-""",
-"""
-public static double FloorNumber(double number) => Math.Floor(number),
-""",
-"""
-public static string FormatDecimal(double number, int decimals) => number.ToString($"F{decimals}"),
-""",
-"""
-public static string GenerateRandomString(int length) => new string(Enumerable.Repeat("ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789", length).Select(s => s[new Random().Next(s.Length)]).ToArray()),
-""",
-"""
-public static bool PathExists(string path) => File.Exists(path) || Directory.Exists(path),
-""",
-"""
-public static List<string> TraverseDirectory(string path) => Directory.GetFiles(path, "*", SearchOption.AllDirectories).ToList(),
-""",
-"""
-public static string GetFileExtension(string path) => Path.GetExtension(path),
-""",
-"""
-public static string GetFileName(string path) => Path.GetFileName(path),
-""",
-"""
-public static string GetFullPath(string path) => Path.GetFullPath(path),
-""",
-"""
-public static string GetPythonVersion() => Environment.Version.ToString(),
-""",
-"""
-public static string GetSystemPlatform() => Environment.OSVersion.Platform.ToString(),
-""",
-"""
-public static int GetCpuCores() => Environment.ProcessorCount,
-""",
-"""
-public static long GetMemorySize() => GC.GetTotalMemory(false),
-""",
-"""
-public static string GetDiskUsage() => new DriveInfo(Path.GetPathRoot(Environment.SystemDirectory)).AvailableFreeSpace.ToString(),
-""",
-"""
-public static string GetIpAddress() => System.Net.Dns.GetHostEntry(System.Net.Dns.GetHostName()).AddressList.FirstOrDefault(ip => ip.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)?.ToString(),
-""",
-"""
-public static bool IsConnectedToInternet() => System.Net.NetworkInformation.NetworkInterface.GetIsNetworkAvailable(),
-""",
-"""
-public static void DownloadFile(string url, string path) => new System.Net.WebClient().DownloadFile(url, path),
-""",
-"""
-public static void UploadFile(string url, string path) => new System.Net.WebClient().UploadFile(url, path),
-""",
-"""
-public static string SendPostRequest(string url, string data) => new System.Net.WebClient().UploadString(url, "POST", data),
-""",
-"""
-public static string SendRequestWithParams(string url, System.Collections.Specialized.NameValueCollection data) => new System.Net.WebClient().UploadValues(url, data),
-""",
-"""
-public static void SetRequestHeader(System.Net.WebClient client, string key, string value) => client.Headers[key] = value,
-""",
-"""
-public static string ParseHtml(string html) => new HtmlAgilityPack.HtmlDocument { Text = html }.DocumentNode.InnerText,
-""",
-"""
-public static string ExtractHtmlTitle(string html) => new HtmlAgilityPack.HtmlDocument { Text = html }.DocumentNode.SelectSingleNode("//title")?.InnerText,
-""",
-"""
-public static List<string> ExtractHtmlLinks(string html) => new HtmlAgilityPack.HtmlDocument { Text = html }.DocumentNode.SelectNodes("//a[@href]")?.Select(node => node.GetAttributeValue("href", "")).ToList(),
-""",
-"""
-public static void DownloadHtmlImages(string html, string path)
-{
-    var doc = new HtmlAgilityPack.HtmlDocument { Text = html };
-    var images = doc.DocumentNode.SelectNodes("//img[@src]")?.Select(node => node.GetAttributeValue("src", "")).ToList();
-    if (images != null) foreach (var img in images) new System.Net.WebClient().DownloadFile(img, Path.Combine(path, Path.GetFileName(img)));
-}
-""",
-"""
-public static Dictionary<string, int> CountWordFrequency(string text) => text.Split(' ').GroupBy(word => word).ToDictionary(group => group.Key, group => group.Count()),
-""",
-"""
-public static void SimulateLogin(string url, System.Collections.Specialized.NameValueCollection data) => new System.Net.WebClient().UploadValues(url, data),
-""",
-"""
-public static string HtmlToText(string html) => new HtmlAgilityPack.HtmlDocument { Text = html }.DocumentNode.InnerText,
-""",
-"""
-public static List<string> ExtractEmails(string text) => System.Text.RegularExpressions.Regex.Matches(text, @"\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*").Select(match => match.Value).ToList(),
-""",
-"""
-public static List<string> ExtractPhoneNumbers(string text) => System.Text.RegularExpressions.Regex.Matches(text, @"\+?\d[\d -]{8,12}\d").Select(match => match.Value).ToList(),
-""",
-"""
-public static List<string> FindAllNumbers(string text) => System.Text.RegularExpressions.Regex.Matches(text, @"\d+").Select(match => match.Value).ToList(),
-""",
-"""
-public static string ReplaceWithRegex(string text, string pattern, string replacement) => System.Text.RegularExpressions.Regex.Replace(text, pattern, replacement),
-""",
-"""
-public static bool IsRegexMatch(string text, string pattern) => System.Text.RegularExpressions.Regex.IsMatch(text, pattern),
-""",
-"""
-public static string RemoveHtmlTags(string html) => System.Text.RegularExpressions.Regex.Replace(html, "<[^>]*>", string.Empty),
-""",
-"""
-public static string EncodeHtmlEntities(string text) => System.Net.WebUtility.HtmlEncode(text),
-""",
-"""
-public static string DecodeHtmlEntities(string text) => System.Net.WebUtility.HtmlDecode(text),
-""",
-"""
-public static void CreateGuiWindow() => new System.Windows.Forms.Form().ShowDialog(),
-""",
-"public static void AddButtonToWindow(Form form, string text, int x, int y, EventHandler onClick) { Button button = new Button(); button.Text = text; button.Location = new Point(x, y); button.Click += onClick; form.Controls.Add(button); }", "public static void ShowMessageBox(string message) { MessageBox.Show(message); }", "public static string GetTextBoxText(TextBox textBox) { return textBox.Text; }", "public static void SetWindowTitle(Form form, string title) { form.Text = title; }", "public static void SetWindowSize(Form form, int width, int height) { form.Size = new Size(width, height); }", "public static void CenterWindow(Form form) { form.StartPosition = FormStartPosition.CenterScreen; }", "public static void AddMenuStrip(Form form, ToolStripMenuItem menuItem) { MenuStrip menuStrip = new MenuStrip(); menuStrip.Items.Add(menuItem); form.Controls.Add(menuStrip); }", "public static void AddComboBox(Form form, int x, int y, EventHandler onSelectedIndexChanged) { ComboBox comboBox = new ComboBox(); comboBox.Location = new Point(x, y); comboBox.SelectedIndexChanged += onSelectedIndexChanged; form.Controls.Add(comboBox); }", "public static void AddRadioButton(Form form, string text, int x, int y) { RadioButton radioButton = new RadioButton(); radioButton.Text = text; radioButton.Location = new Point(x, y); form.Controls.Add(radioButton); }", "public static void AddCheckBox(Form form, string text, int x, int y) { CheckBox checkBox = new CheckBox(); checkBox.Text = text; checkBox.Location = new Point(x, y); form.Controls.Add(checkBox); }", "public static void DisplayImage(Form form, string imagePath, int x, int y) { PictureBox pictureBox = new PictureBox(); pictureBox.Image = Image.FromFile(imagePath); pictureBox.Location = new Point(x, y); form.Controls.Add(pictureBox); }", "public static void PlayAudioFile(string filePath) { SoundPlayer player = new SoundPlayer(filePath); player.Play(); }", "public static void PlayVideoFile(Form form, string filePath, int x, int y) { AxWMPLib.AxWindowsMediaPlayer player = new AxWMPLib.AxWindowsMediaPlayer(); player.CreateControl(); player.URL = filePath; player.Location = new Point(x, y); form.Controls.Add(player); }", "public static TimeSpan GetCurrentPlayTime(AxWMPLib.AxWindowsMediaPlayer player) { return player.Ctlcontrols.currentPosition; }", "public static void CaptureScreen(string filePath) { Bitmap bitmap = new Bitmap(Screen.PrimaryScreen.Bounds.Width, Screen.PrimaryScreen.Bounds.Height); Graphics graphics = Graphics.FromImage(bitmap); graphics.CopyFromScreen(0, 0, 0, 0, bitmap.Size); bitmap.Save(filePath); }", "public static void RecordScreen(string filePath, int duration) { // Simulated implementation }", "public static Point GetMousePosition() { return Cursor.Position; }", "public static void SimulateKeyboardInput(string text) { SendKeys.SendWait(text); }", "public static void SimulateMouseClick(int x, int y) { Cursor.Position = new Point(x, y); mouse_event(0x0002 | 0x0004, x, y, 0, 0); }", "public static long GetCurrentTimestamp() { return DateTimeOffset.UtcNow.ToUnixTimeSeconds(); }", "public static DateTime TimestampToDate(long timestamp) { return DateTimeOffset.FromUnixTimeSeconds(timestamp).DateTime; }", "public static long DateToTimestamp(DateTime date) { return new DateTimeOffset(date).ToUnixTimeSeconds(); }", "public static string GetCurrentDayOfWeek() { return DateTime.Now.DayOfWeek.ToString(); }", "public static int GetDaysInCurrentMonth() { return DateTime.DaysInMonth(DateTime.Now.Year, DateTime.Now.Month); }", "public static DateTime GetFirstDayOfYear() { return new DateTime(DateTime.Now.Year, 1, 1); }", "public static DateTime GetLastDayOfYear() { return new DateTime(DateTime.Now.Year, 12, 31); }", "public static DateTime GetFirstDayOfMonth(int year, int month) { return new DateTime(year, month, 1); }", "public static DateTime GetLastDayOfMonth(int year, int month) { return new DateTime(year, month, DateTime.DaysInMonth(year, month)); }", "public static bool IsWeekday() { DayOfWeek day = DateTime.Now.DayOfWeek; return day != DayOfWeek.Saturday && day != DayOfWeek.Sunday; }", "public static bool IsWeekend() { DayOfWeek day = DateTime.Now.DayOfWeek; return day == DayOfWeek.Saturday || day == DayOfWeek.Sunday; }", "public static int GetCurrentHour() { return DateTime.Now.Hour; }", "public static int GetCurrentMinute() { return DateTime.Now.Minute; }", "public static int GetCurrentSecond() { return DateTime.Now.Second; }", "public static void DelayOneSecond() { Thread.Sleep(1000); }", "public static long GetMillisecondTimestamp() { return DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(); }", "public static string FormatTimeToString(DateTime date, string format) { return date.ToString(format); }", "public static DateTime ParseStringToTime(string dateString, string format) { return DateTime.ParseExact(dateString, format, CultureInfo.InvariantCulture); }", "public static void CreateThread(ThreadStart start) { Thread thread = new Thread(start); thread.Start(); }", "public static void PauseThread(Thread thread) { thread.Suspend(); }", "public static void RunFunctionInThread(ThreadStart start) { Thread thread = new Thread(start); thread.Start(); }", "public static string GetCurrentThreadName() { return Thread.CurrentThread.Name; }", "public static void SetThreadAsDaemon(Thread thread) { thread.IsBackground = true; }", "public static void LockThread(object lockObject, Action action) { lock (lockObject) { action(); } }", "public static void CreateProcess(string fileName) { Process.Start(fileName); }", "public static int GetProcessId() { return Process.GetCurrentProcess().Id; }", "public static bool IsProcessAlive(int processId) { try { Process.GetProcessById(processId); return true; } catch { return false; } }", "public static void RunFunctionInProcess(Action action) { Task.Run(action); }", "public static void UseQueueToPassValue<T>(Queue<T> queue, T value) { queue.Enqueue(value); }", "public static void UsePipeToCommunicate() { // Simulated implementation }", "public static void LimitCpuUsage() { // Simulated implementation }", "public static void RunShellCommand(string command) { Process.Start(\"cmd.exe\", \"/c \" + command); }", "public static string GetCommandOutput(string command) { Process process = new Process(); process.StartInfo.FileName = \"cmd.exe\"; process.StartInfo.Arguments = \"/c \" + command; process.StartInfo.RedirectStandardOutput = true; process.StartInfo.UseShellExecute = false; process.Start(); return process.StandardOutput.ReadToEnd(); }", "public static int GetCommandExitCode(string command) { Process process = Process.Start(\"cmd.exe\", \"/c \" + command); process.WaitForExit(); return process.ExitCode; }", "public static bool IsCommandSuccessful(string command) { return GetCommandExitCode(command) == 0; }", "public static string GetCurrentScriptPath() { return Assembly.GetExecutingAssembly().Location; }", "public static string[] GetCommandLineArgs() { return Environment.GetCommandLineArgs(); }", "public static void UseArgParse() { // Simulated implementation }", "public static void GenerateCommandHelp() { // Simulated implementation }", "public static void ListPythonModules() { // Simulated implementation }", "public static void InstallPythonPackage(string package) { // Simulated implementation }", "public static void UninstallPythonPackage(string package) { // Simulated implementation }", "public static string GetPackageVersion(string package) { // Simulated implementation return \"\"; }", "public static void UseVirtualEnvironment() { // Simulated implementation }", "public static void ListInstalledPackages() { // Simulated implementation }", "public static void UpgradePythonPackage(string package) { // Simulated implementation }", "public static void ConnectToLocalDatabase(string connectionString) { SqlConnection connection = new SqlConnection(connectionString); connection.Open(); }", "public static DataTable ExecuteSqlQuery(SqlConnection connection, string query) { SqlCommand command = new SqlCommand(query, connection); SqlDataAdapter adapter = new SqlDataAdapter(command); DataTable table = new DataTable(); adapter.Fill(table); return table; }", "public static void InsertRecord(SqlConnection connection, string table, Dictionary<string, object> values) { string columns = string.Join(\",\", values.Keys); string parameters = string.Join(\",\", values.Keys.Select(k => \"@\" + k)); string query = $\"INSERT INTO {table} ({columns}) VALUES ({parameters})\"; SqlCommand command = new SqlCommand(query, connection); foreach (var pair in values) { command.Parameters.AddWithValue(\"@\" + pair.Key, pair.Value); } command.ExecuteNonQuery(); }", "public static void DeleteRecord(SqlConnection connection, string table, string condition) { string query = $\"DELETE FROM {table} WHERE {condition}\"; SqlCommand command = new SqlCommand(query, connection); command.ExecuteNonQuery(); }", "public static void UpdateRecord(SqlConnection connection, string table, Dictionary<string, object> values, string condition) { string setClause = string.Join(\",\", values.Keys.Select(k => $\"{k} = @{k}\")); string query = $\"UPDATE {table} SET {setClause} WHERE {condition}\"; SqlCommand command = new SqlCommand(query, connection); foreach (var pair in values) { command.Parameters.AddWithValue(\"@\" + pair.Key, pair.Value); } command.ExecuteNonQuery(); }", "public static DataTable QueryMultipleRecords(SqlConnection connection, string query) { SqlCommand command = new SqlCommand(query, connection); SqlDataAdapter adapter = new SqlDataAdapter(command); DataTable table = new DataTable(); adapter.Fill(table); return table; }", "public static void UseParameterizedQuery(SqlConnection connection, string query, Dictionary<string, object> parameters) { SqlCommand command = new SqlCommand(query, connection); foreach (var pair in parameters) { command.Parameters.AddWithValue(\"@\" + pair.Key, pair.Value); } command.ExecuteNonQuery(); }", "public static void CloseDatabaseConnection(SqlConnection connection) { connection.Close(); }", "public static void CreateDatabaseTable(SqlConnection connection, string table, Dictionary<string, string> columns) { string columnDefinitions = string.Join(\",\", columns.Select(pair => $\"{pair.Key} {pair.Value}\")); string query = $\"CREATE TABLE {table} ({columnDefinitions})\"; SqlCommand command = new SqlCommand(query, connection); command.ExecuteNonQuery(); }", "public static void DeleteDatabaseTable(SqlConnection connection, string table) { string query = $\"DROP TABLE {table}\"; SqlCommand command = new SqlCommand(query, connection); command.ExecuteNonQuery(); }", "public static bool TableExists(SqlConnection connection, string table) { string query = $\"SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = '{table}'\"; SqlCommand command = new SqlCommand(query, connection); return command.ExecuteScalar() != null; }", "public static DataTable GetAllTables(SqlConnection connection) { string query = \"SELECT * FROM INFORMATION_SCHEMA.TABLES\"; SqlCommand command = new SqlCommand(query, connection); SqlDataAdapter adapter = new SqlDataAdapter(command); DataTable table = new DataTable(); adapter.Fill(table); return table; }", "public static void UseOrmInsertData<T>(DbContext context, T entity) where T : class { context.Set<T>().Add(entity); context.SaveChanges(); }", "public static List<T> UseOrmQueryData<T>(DbContext context) where T : class { return context.Set<T>().ToList(); }", "public static void UseOrmDeleteData<T>(DbContext context, T entity) where T : class { context.Set<T>().Remove(entity); context.SaveChanges(); }", "public static void UseOrmUpdateData<T>(DbContext context, T entity) where T : class { context.Set<T>().Update(entity); context.SaveChanges(); }", "public static void DefineDatabaseModelClass() { // Simulated implementation }", "public static void ImplementModelClassInheritance() { // Simulated implementation }", "public static void SetPrimaryKeyField() { // Simulated implementation }", "public static void SetUniqueConstraint() { // Simulated implementation }", "public static void SetFieldDefaultValue() { // Simulated implementation }", "public static void ExportDataToCsv(DataTable table, string filePath) { StringBuilder sb = new StringBuilder(); foreach (DataRow row in table.Rows) { sb.AppendLine(string.Join(\",\", row.ItemArray)); } File.WriteAllText(filePath, sb.ToString()); }", "public static void ExportDataToExcel(DataTable table, string filePath) { // Simulated implementation }", "public static void ExportDataToJson(DataTable table, string filePath) { string json = JsonConvert.SerializeObject(table); File.WriteAllText(filePath, json); }", "public static DataTable ReadDataFromExcel(string filePath) { // Simulated implementation return new DataTable(); }", "public static void MergeExcelFiles(List<string> filePaths, string outputPath) { // Simulated implementation }", "public static void AddNewSheetToExcel(string filePath, string sheetName) { // Simulated implementation }", "public static void CopyExcelSheetStyle(string sourceFilePath, string targetFilePath) { // Simulated implementation }", "public static void SetExcelCellColor(string filePath, string sheetName, int row, int column, string color) { // Simulated implementation }", "public static void SetExcelFontStyle(string filePath, string sheetName, int row, int column, string fontName, int fontSize) { // Simulated implementation }", "public static string ReadExcelCellContent(string filePath, string sheetName, int row, int column) { // Simulated implementation return \"\"; }", "public static void WriteExcelCellContent(string filePath, string sheetName, int row, int column, string content) { // Simulated implementation }", "public static Size GetImageDimensions(string imagePath) { Image image = Image.FromFile(imagePath); return image.Size; }", "public static void ResizeImage(string imagePath, string outputPath, int width, int height) { Image image = Image.FromFile(imagePath); Bitmap resizedImage = new Bitmap(image, width, height); resizedImage.Save(outputPath); }"
-
+"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()); }"