Update app.py

app.py

@@ -14,422 +14,342 @@ app.logger = logging.getLogger("CodeSearchAPI")
 # 预定义代码片段
 CODE_SNIPPETS = [
 
-    
-"puts 'Hello, World!'",
-"def sum(a, b); a + b; end",
-"rand",
-"def even?(num); num.even?; end",
-"str.length",
-"Date.today",
-"File.exist?('file.txt')",
-"File.read('file.txt')",
-"File.write('file.txt', 'content')",
-"Time.now",
-"str.upcase",
-"str.downcase",
-"str.reverse",
-"list.size",
-"list.max",
-"list.min",
-"list.sort",
-"list1 + list2",
-"list.delete(element)",
-"list.empty?",
-"str.count(char)",
-"str.include?(substring)",
-"num.to_s",
-"str.to_i",
-"str.match?(/^\d+$/)",
-"list.index(element)",
-"list.clear",
-"list.reverse",
-"list.uniq",
-"list.include?(value)",
-"{}",
-"hash[key] = value",
-"hash.delete(key)",
-"hash.keys",
-"hash.values",
-"hash1.merge(hash2)",
-"hash.empty?",
-"hash[key]",
-"hash.key?(key)",
-"hash.clear",
-"File.readlines('file.txt').size",
-"File.write('file.txt', list.join('\\n'))",
-"File.read('file.txt').split('\\n')",
-"File.read('file.txt').split.size",
-"def leap_year?(year); (year % 400 == 0) || (year % 100 != 0 && year % 4 == 0); end",
-"Time.now.strftime('%Y-%m-%d %H:%M:%S')",
-"(Date.today - Date.new(2023, 1, 1)).to_i",
-"Dir.pwd",
-"Dir.entries('.')",
-"Dir.mkdir('new_dir')",
-"Dir.rmdir('new_dir')",
-"File.file?('path')",
-"File.directory?('path')",
-"File.size('file.txt')",
-"File.rename('old.txt', 'new.txt')",
-"FileUtils.cp('source.txt', 'destination.txt')",
-"FileUtils.mv('source.txt', 'destination.txt')",
-"File.delete('file.txt')",
-"ENV['VAR_NAME']",
-"ENV['VAR_NAME'] = 'value'",
-"system('open https://example.com')",
-"require 'net/http'; Net::HTTP.get(URI('https://example.com'))",
-"require 'json'; JSON.parse(json_string)",
-"require 'json'; File.write('file.json', JSON.dump(data))",
-"require 'json'; JSON.parse(File.read('file.json'))",
-"list.join",
-"str.split(',')",
-"list.join(',')",
-"list.join('\\n')",
-"str.split",
-"str.split(delimiter)",
-"str.chars",
-"str.gsub(old, new)",
-"str.gsub(' ', '')",
-"str.gsub(/[^a-zA-Z0-9]/, '')",
-"str.empty?",
-"str == str.reverse",
-"require 'csv'; CSV.open('file.csv', 'w') { |csv| csv << ['data'] }",
-"require 'csv'; CSV.read('file.csv')",
-"require 'csv'; CSV.read('file.csv').size",
-"list.shuffle",
-"list.sample",
-"list.sample(n)",
-"rand(6) + 1",
-"rand(2) == 0 ? 'Heads' : 'Tails'",
-"SecureRandom.alphanumeric(8)",
-"format('#%06x', rand(0xffffff))",
-"SecureRandom.uuid",
-"class MyClass; end",
-"MyClass.new",
-"class MyClass; def my_method; end; end",
-"class MyClass; attr_accessor :my_attr; end",
-"class ChildClass < ParentClass; end",
-"class ChildClass < ParentClass; def my_method; super; end; end",
-"class MyClass; def self.class_method; end; end",
-"class MyClass; def self.static_method; end; end",
-"obj.is_a?(Class)",
-"obj.instance_variable_get(:@attr)",
-"obj.instance_variable_set(:@attr, value)",
-"obj.instance_variable_defined?(:@attr)",
-"begin; risky_operation; rescue => e; puts e; end",
-"""class CustomError < StandardError
-end
-raise CustomError, 'error occurred'""",
-"begin; raise 'oops'; rescue => e; e.message; end",
-"""require 'logger'
-logger = Logger.new('error.log')
-logger.error('error occurred')""",
-"start_time = Time.now",
-"Time.now - start_time",
-"20.times { |i| print \"\\r[#{'='*(i+1)}#{' '*(19-i)}]\"; sleep(0.1) }",
-"sleep(1)",
-"square = ->(x) { xx }",
-"squares = [1,2,3].map { |n| nn }",
-"evens = [1,2,3,4].select { |n| n.even? }",
-"sum = [1,2,3].reduce(0) { |acc,n| acc+n }",
-"doubles = [1,2,3,4,5].map { |n| n2 }",
-"hash = [1,2,3].map { |n| [n, n2] }.to_h",
-"require 'set'; s = Set.new([1,2,3].map { |n| n*2 })",
-"intersection = a & b",
-"union = a | b",
-"diff = a - b",
-"filtered = list.compact",
-"begin; File.open('file.txt'); rescue; false; end",
-"x.is_a?(String)",
-"bool = ['true','1'].include?(str.downcase)",
-"puts 'yes' if x > 0",
-"i=0; while i<5; i+=1; end",
-"for item in [1,2,3]; puts item; end",
-"""h = {a:1, b:2}
-for k, v in h
-puts "#{k}:#{v}"
-end""",
-"""for c in 'hello'.chars
-puts c
-end""",
-"""for i in 1..5
-break if i==3
-puts i
-end""",
-"""for i in 1..5
-next if i==3
-puts i
-end""",
-"def foo; end",
-"def foo(a=1); a; end",
-"def foo; [1,2]; end",
-"def foo(*args); args; end",
-"def foo(a:, b:); a+b; end",
-"""def foo
-end
-start = Time.now
-foo
-puts Time.now - start""",
-"""def decorate(f)
-->(args) { puts 'before'; result = f.call(args); puts 'after'; result }
-end""",
-"""def fib(n, memo={})
-return memo[n] if memo[n]
-memo[n] = n<2 ? n : fib(n-1, memo) + fib(n-2, memo)
-end""",
-"gen = Enumerator.new { |y| i=0; loop { y << i; i+=1 } }",
-"def foo; yield 1; end",
-"gen.next",
-"itr = [1,2,3].each",
-"""itr = [1,2,3].each
-loop do
-puts itr.next
-end""",
-"[1,2].each_with_index { |v, i| puts i, v }",
-"zipped = [1,2].zip(['a','b'])",
-"h = [1,2].zip(['a','b']).to_h",
-"[1,2] == [1,2]",
-"{a:1, b:2} == {b:2, a:1}",
-"require 'set'; Set.new([1,2]) == Set.new([2,1])",
-"unique = [1,2,1].uniq",
-"s.clear",
-"s.empty?",
-"s.add(1)",
-"s.delete(1)",
-"s.include?(1)",
-"s.size",
-"!(a & b).empty?",
-"[1,2].all? { |e| [1,2,3].include?(e) }",
-"'hi'.include?('h')",
-"str[0]",
-"str[-1]",
-"File.extname(path) == '.txt'",
-"['.png','.jpg','.jpeg','.gif'].include?(File.extname(path))",
-"x.round",
-"x.ceil",
-"x.floor",
-"sprintf('%.2f', x)",
-"require 'securerandom'; SecureRandom.alphanumeric(8)",
-"File.exist?('path')",
-"Dir['**/'].each { |f| puts f }",
-"File.extname('path.txt')",
-"File.basename(path)",
-"File.expand_path(path)",
-"RUBY_VERSION",
-"RUBY_PLATFORM",
-"require 'etc'; Etc.nprocessors",
-"mem = grep MemTotal /proc/meminfo",
-"df = df -h /",
-"""require 'socket'
-ip = Socket.ip_address_list.detect(&:ipv4_private).ip_address""",
-"system('ping -c1 8.8.8.8 > /dev/null 2>&1')",
-"""require 'open-uri'
-File.open('file', 'wb') { |f| f.write open(url).read }""",
-"""def upload(file)
-puts 'Uploading'
-end""",
-"""require 'net/http'
-uri = URI(url)
-Net::HTTP.post_form(uri, key: 'value')""",
-"""uri = URI(url)
-uri.query = URI.encode_www_form(params)
-Net::HTTP.get(uri)""",
-"""require 'net/http'
-uri = URI(url)
-req = Net::HTTP::Get.new(uri)
-req['User-Agent'] = 'Custom'
-res = Net::HTTP.start(uri.hostname, uri.port) { |http| http.request(req) }""",
-"require 'nokogiri'; doc = Nokogiri::HTML(html)",
-"doc.at('title').text",
-"links = doc.css('a').map { |a| a['href'] }",
-"""doc.css('img').each do |img|
-open(img['src']).each do |chunk|
-File.open(File.basename(img['src']), 'ab') { |f| f.write chunk }
-end
-end""",
-"""freq = Hash.new(0)
-text.split.each { |w| freq[w] += 1 }""",
-"""require 'net/http'
-res = Net::HTTP.post_form(URI(login_url), username: 'u', password: 'p')""",
-"Nokogiri::HTML(html).text",
-"emails = text.scan(/\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/)",
-"phones = text.scan(/\b\d{3}-\d{3}-\d{4}\b/)",
-"nums = text.scan(/\d+/)",
-"new = text.gsub(/foo/, 'bar')",
-"!!(text =~ /pattern/)",
-"clean = text.gsub(/<[^>]>/, '')",
-"CGI.escapeHTML(text)",
-"CGI.unescapeHTML(text)",
-"""require 'tk'
-root = TkRoot.new { title 'App' }
-Tk.mainloop""",
-"require 'tk'",
-    """root = TkRoot.new
-button = TkButton.new(root) {text 'Click Me'; command { Tk.messageBox(message: 'Button Clicked!') }}
-button.pack""",
-    """Tk.messageBox(message: 'Hello, World!')""",
-    """entry = TkEntry.new(root).pack
-entry.get""",
-    """root.title = 'My Window'""",
-    """root.geometry('400x300')""",
-    """root.geometry('+%d+%d' % [(root.winfo_screenwidth() - root.winfo_reqwidth()) / 2, (root.winfo_screenheight() - root.winfo_reqheight()) / 2])""",
-    """menu = TkMenu.new(root)
-root['menu'] = menu
-menu.add('command', 'label' => 'File')""",
-    """combobox = Tk::Tile::Combobox.new(root).pack""",
-    """radio = TkRadioButton.new(root) {text 'Option 1'}.pack""",
-    """check = TkCheckButton.new(root) {text 'Check Me'}.pack""",
-    """image = TkPhotoImage.new(file: 'image.png')
-label = TkLabel.new(root) {image image}.pack""",
-    """`afplay audio.mp3`""",
-    """`ffplay video.mp4`""",
-    """`ffmpeg -i video.mp4 -f null - 2>&1 | grep 'time=' | awk '{print $2}'`""",
-    """`screencapture screen.png`""",
-    """`ffmpeg -f avfoundation -i "1" -t 10 screen.mp4`""",
-    """`cliclick p:.`""",
-    """`cliclick kd:cmd kp:space ku:cmd`""",
-    """`cliclick c:.`""",
-    """Time.now.to_i""",
-    """Time.at(timestamp).strftime('%Y-%m-%d')""",
-    """Time.parse(date).to_i""",
-    """Time.now.strftime('%A')""",
-    """Time.days_in_month(Time.now.month, Time.now.year)""",
-    """Time.new(Time.now.year, 1, 1)""",
-    """Time.new(Time.now.year, 12, 31)""",
-    """Time.new(year, month, 1)""",
-    """Time.new(year, month, -1)""",
-    """Time.now.wday.between?(1, 5)""",
-    """Time.now.wday.between?(6, 7)""",
-    """Time.now.hour""",
-    """Time.now.min""",
-    """Time.now.sec""",
-    """sleep(1)""",
-    """(Time.now.to_f * 1000).to_i""",
-    """Time.now.strftime('%Y-%m-%d %H:%M:%S')""",
-    """Time.parse(time_str)""",
-    """Thread.new { puts 'Hello from thread' }""",
-    """sleep(1)""",
-    """threads = []
-3.times { threads << Thread.new { puts 'Hello from thread' } }
-threads.each(&:join)""",
-    """Thread.current.name""",
-    """thread = Thread.new { puts 'Hello from thread' }
-thread.abort_on_exception = true""",
-    """mutex = Mutex.new
-mutex.synchronize { puts 'Hello from synchronized thread' }""",
-    """pid = Process.spawn('sleep 5')""",
-    """Process.pid""",
-    """Process.kill(0, pid) rescue false""",
-    """pids = []
-3.times { pids << Process.spawn('sleep 5') }
-pids.each { |pid| Process.wait(pid) }""",
-    """queue = Queue.new
-queue.push('Hello')
-queue.pop""",
-    """reader, writer = IO.pipe
-writer.puts 'Hello'
-reader.gets""",
-    """Process.setrlimit(:CPU, 50)""",
-    """`ls`""",
-    """`ls`.chomp""",
-    """$?.exitstatus""",
-    """$?.success?""",
-    """File.expand_path(__FILE__)""",
-    """ARGV""",
-    """require 'optparse'
-OptionParser.new { |opts| opts.on('-h', '--help', 'Show help') { puts opts } }.parse!""",
-    """OptionParser.new { |opts| opts.on('-h', '--help', 'Show help') { puts opts } }.parse!""",
-    """Gem.loaded_specs.keys""",
-    """`gem install package_name`""",
-    """`gem uninstall package_name`""",
-    """Gem.loaded_specs['package_name'].version.to_s""",
-    """`bundle exec ruby script.rb`""",
-    """Gem::Specification.map(&:name)""",
-    """`gem update package_name`""",
-    """require 'sqlite3'
-db = SQLite3::Database.new('test.db')""",
-    """db.execute('SELECT * FROM table')""",
-    """db.execute('INSERT INTO table (column) VALUES (?)', 'value')""",
-    """db.execute('DELETE FROM table WHERE id = ?', 1)""",
-    """db.execute('UPDATE table SET column = ? WHERE id = ?', 'new_value', 1)""",
-    """db.execute('SELECT * FROM table').each { |row| puts row }""",
-    """db.execute('SELECT * FROM table WHERE column = ?', 'value')""",
-    """db.close""",
-    """db.execute('CREATE TABLE table (id INTEGER PRIMARY KEY, column TEXT)')""",
-    """db.execute('DROP TABLE table')""",
-    """db.table_info('table').any?""",
-    """db.execute('SELECT name FROM sqlite_master WHERE type = "table"')""",
-    """class Model < ActiveRecord::Base
-end
-Model.create(column: 'value')""",
-    """Model.find_by(column: 'value')""",
-    """Model.find_by(column: 'value').destroy""",
-    """Model.find_by(column: 'value').update(column: 'new_value')""",
-    """class Model < ActiveRecord::Base
-end""",
-    """class ChildModel < ParentModel
-end""",
-    """class Model < ActiveRecord::Base
-  self.primary_key = 'id'
-end""",
-    """class Model < ActiveRecord::Base
-  validates_uniqueness_of :column
-end""",
-    """class Model < ActiveRecord::Base
-  attribute :column, default: 'value'
-end""",
-    """require 'csv'
-CSV.open('data.csv', 'w') { |csv| csv << ['column1', 'column2'] }""",
-    """require 'spreadsheet'
-book = Spreadsheet::Workbook.new
-sheet = book.create_worksheet
-sheet[0, 0] = 'Hello'
-book.write('data.xls')""",
-    """require 'json'
-File.write('data.json', {key: 'value'}.to_json)""",
-    """require 'spreadsheet'
-book = Spreadsheet.open('data.xls')
-sheet = book.worksheet(0)
-sheet.each { |row| puts row }""",
-    """require 'spreadsheet'
-book1 = Spreadsheet.open('file1.xls')
-book2 = Spreadsheet.open('file2.xls')
-book1.worksheets.each { |sheet| book2.add_worksheet(sheet) }
-book2.write('merged.xls')""",
-    """require 'spreadsheet'
-book = Spreadsheet::Workbook.new
-book.create_worksheet(name: 'New Sheet')
-book.write('data.xls')""",
-    """require 'spreadsheet'
-book = Spreadsheet.open('data.xls')
-sheet = book.worksheet(0)
-new_sheet = book.create_worksheet
-new_sheet.format_with(sheet)
-book.write('data.xls')""",
-    """require 'spreadsheet'
-book = Spreadsheet.open('data.xls')
-sheet = book.worksheet(0)
-sheet.row(0).set_format(0, Spreadsheet::Format.new(color: :red))
-book.write('data.xls')""",
-    """require 'spreadsheet'
-book = Spreadsheet.open('data.xls')
-sheet = book.worksheet(0)
-sheet.row(0).set_format(0, Spreadsheet::Format.new(weight: :bold))
-book.write('data.xls')""",
-    """require 'spreadsheet'
-book = Spreadsheet.open('data.xls')
-sheet = book.worksheet(0)
-sheet[0, 0]""",
-    """require 'spreadsheet'
-book = Spreadsheet::Workbook.new
-sheet = book.create_worksheet
-sheet[0, 0] = 'Hello'
-book.write('data.xls')""",
-    """require 'rmagick'
-image = Magick::Image.read('image.png').first
-[image.columns, image.rows]""",
-    """require 'rmagick'
-image = Magick::Image.read('image.png').first
-image.resize!(100, 100)"""
+    "#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 */ }"
+