[*] add contribution docs and refactor core modules

Added CONTRIBUTING.md, architecture documentation, and GitHub issue/PR templates. Refactored a lot of things with `cargo fmt`

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,32 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: bug
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '...'
+3. Scroll down to '...'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Environment (please complete the following information):**
+ - OS: [e.g. Windows 11, macOS 14, Ubuntu 22.04]
+ - Rust Version: [e.g. 1.91.1]
+ - Commit Hash: [e.g. a1b2c3d]
+
+**Additional context**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: enhancement
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex: I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,31 @@
+## Description
+Please include a summary of the change and which issue is fixed. Please also include relevant motivation and context. List any dependencies that are required for this change.
+
+Fixes # (issue)
+
+## Type of change
+
+Please delete options that are not relevant.
+
+- [ ] Bug fix (non-breaking change which fixes an issue)
+- [ ] New feature (non-breaking change which adds functionality)
+- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected)
+- [ ] This change requires a documentation update
+
+## How Has This Been Tested?
+
+Please describe the tests that you ran to verify your changes. Provide instructions so we can reproduce. Please also list any relevant details for your test configuration
+
+- [ ] Test A
+- [ ] Test B
+
+## Checklist:
+
+- [ ] My code follows the style guidelines of this project
+- [ ] I have performed a self-review of my own code
+- [ ] I have commented my code, particularly in hard-to-understand areas
+- [ ] I have made corresponding changes to the documentation
+- [ ] My changes generate no new warnings
+- [ ] I have added tests that prove my fix is effective or that my feature works
+- [ ] New and existing unit tests pass locally with my changes
+- [ ] Any dependent changes have been merged and published in downstream modules

CONTRIBUTING.md

@@ -0,0 +1,64 @@
+# Contributing to oboromi
+
+First off, thanks for taking the time to contribute!
+
+The following is a set of guidelines for contributing to `oboromi`. These are mostly guidelines, not rules. Use your best judgment, and feel free to propose changes to this document in a pull request.
+
+## Getting Started
+
+### Prerequisites
+
+To build and run `oboromi`, you will need:
+
+*   **Rust**: Latest stable version. [Install Rust](https://www.rust-lang.org/tools/install).
+*   **CMake**: Version 3.16 or higher.
+*   **Ninja**: Build system.
+*   **C++ Compiler**: MSVC (Windows) or Clang (macOS/Linux).
+
+### Building the Project
+
+1.  Clone the repository:
+    ```bash
+    git clone https://github.com/0xNikilite/oboromi
+    cd oboromi
+    ```
+
+2.  Build and run:
+    ```bash
+    cargo run
+    ```
+
+### Running Tests (no tests yet)
+
+We prioritize correctness. Please ensure all tests pass before submitting a PR.
+
+```bash
+cargo test
+```
+
+## Code Style
+
+We follow standard Rust community guidelines.
+
+*   **Formatting**: Run `cargo fmt` to ensure your code is formatted correctly.
+*   **Linting**: Run `cargo clippy` to catch common mistakes and improve code quality. (rn it's normal if it fails)
+
+## Submitting a Pull Request
+
+1.  Fork the repository and create your branch from `main`.
+2.  If you've added code that should be tested, add tests.
+3.  Ensure the test suite passes.
+4.  Make sure your code lints.
+5.  Issue that pull request!
+
+## Reporting Bugs
+
+Bugs are tracked as GitHub issues. When filing an issue, please explain the problem and include additional details to help maintainers reproduce the problem:
+
+*   Use a clear and descriptive title for the issue to identify the problem.
+*   Describe the exact steps which reproduce the problem.
+*   Describe the behavior you observed after following the steps.
+
+## License
+
+By contributing, you agree that your contributions will be licensed under its Mozilla Public License 2.0.

core/build.rs

@@ -1,4 +1,4 @@
 fn main() {
     println!("cargo:rerun-if-changed=build.rs");
     println!("cargo:warning=Building with Unicorn backend");
-}
+}

core/src/cpu/mod.rs

@@ -1,3 +1,3 @@
 pub mod unicorn_interface;
 
-pub use unicorn_interface::UnicornCPU;
+pub use unicorn_interface::UnicornCPU;

core/src/cpu/unicorn_interface.rs

@@ -1,6 +1,6 @@
+use std::sync::{Arc, Mutex};
 use unicorn_engine::{Arch, Mode, Prot};
 use unicorn_engine::{RegisterARM64, Unicorn};
-use std::sync::{Arc, Mutex};
 
 const MEMORY_SIZE: u64 = 8 * 1024 * 1024; // 8MB
 const MEMORY_BASE: u64 = 0x0;
@@ -30,7 +30,7 @@ impl UnicornCPU {
 
         // Initialize stack pointer to end of memory
         let _ = emu.reg_write(RegisterARM64::SP, MEMORY_SIZE - 0x1000);
-        
+
         Some(Self {
             emu: Arc::new(Mutex::new(emu)),
         })
@@ -40,27 +40,27 @@ impl UnicornCPU {
     pub fn run(&self) -> u64 {
         let mut emu = self.emu.lock().unwrap();
         let pc = emu.reg_read(RegisterARM64::PC).unwrap_or(0);
-    
+
         // Run until we hit a BRK instruction or error
         match emu.emu_start(pc, 0xFFFF_FFFF_FFFF_FFFF, 0, 0) {
             Ok(_) => 1, // Success - normal completion
             Err(e) => {
-            // BRK instruction causes an error, which is expected
-            if format!("{:?}", e).contains("EXCEPTION") {
-                1 // Success - terminated by BRK
-            } else {
-                eprintln!("Emulation error: {:?}", e);
-                0 // Failure - actual emulation error
+                // BRK instruction causes an error, which is expected
+                if format!("{:?}", e).contains("EXCEPTION") {
+                    1 // Success - terminated by BRK
+                } else {
+                    eprintln!("Emulation error: {:?}", e);
+                    0 // Failure - actual emulation error
+                }
             }
         }
     }
-}
 
     /// Execute a single step
     pub fn step(&self) -> u64 {
         let mut emu = self.emu.lock().unwrap();
         let pc = emu.reg_read(RegisterARM64::PC).unwrap_or(0);
-        
+
         match emu.emu_start(pc, pc + 4, 0, 1) {
             Ok(_) => 0,
             Err(_) => 1,
@@ -79,7 +79,7 @@ impl UnicornCPU {
         if reg_index > 30 {
             return 0;
         }
-        
+
         let reg = match reg_index {
             0 => RegisterARM64::X0,
             1 => RegisterARM64::X1,
@@ -114,7 +114,7 @@ impl UnicornCPU {
             30 => RegisterARM64::X30,
             _ => return 0,
         };
-        
+
         emu.reg_read(reg).unwrap_or(0)
     }
 
@@ -124,7 +124,7 @@ impl UnicornCPU {
         if reg_index > 30 {
             return;
         }
-        
+
         let reg = match reg_index {
             0 => RegisterARM64::X0,
             1 => RegisterARM64::X1,
@@ -159,7 +159,7 @@ impl UnicornCPU {
             30 => RegisterARM64::X30,
             _ => return,
         };
-        
+
         let _ = emu.reg_write(reg, value);
     }
 

core/src/gpu/mod.rs

@@ -1,4 +1,4 @@
 pub mod sm86;
-pub mod state;
 pub mod spirv;
+pub mod state;
 pub mod test;

core/src/gpu/sm86.rs

@@ -3,7 +3,7 @@
 use crate::gpu::spirv;
 
 pub struct Decoder<'a> {
-    pub ir: &'a mut spirv::Emitter
+    pub ir: &'a mut spirv::Emitter,
 }
 impl<'a> Decoder<'a> {
     pub fn al2p(&mut self, inst: u128) {
@@ -2179,7 +2179,9 @@ impl<'a> Decoder<'a> {
         let _up = (((inst >> 67) & 0x1) << 0);
         let _pr = (((inst >> 68) & 0x7) << 0);
         let _memdesc = (((inst >> 71) & 0x1) << 0);
-        let _lop = (((inst >> 72) & 0x1f) << 11) | (((inst >> 64) & 0x7) << 8) | (((inst >> 16) & 0xff) << 0);
+        let _lop = (((inst >> 72) & 0x1f) << 11)
+            | (((inst >> 64) & 0x7) << 8)
+            | (((inst >> 16) & 0xff) << 0);
         let _pq = (((inst >> 77) & 0x7) << 0);
         let _ftz = (((inst >> 80) & 0x1) << 0);
         let _pu = (((inst >> 81) & 0x7) << 0);
@@ -2241,7 +2243,9 @@ impl<'a> Decoder<'a> {
         let _pg_not = (((inst >> 15) & 0x1) << 0);
         let _up = (((inst >> 67) & 0x1) << 0);
         let _pr = (((inst >> 68) & 0x7) << 0);
-        let _lop = (((inst >> 72) & 0x1f) << 11) | (((inst >> 64) & 0x7) << 8) | (((inst >> 16) & 0xff) << 0);
+        let _lop = (((inst >> 72) & 0x1f) << 11)
+            | (((inst >> 64) & 0x7) << 8)
+            | (((inst >> 16) & 0xff) << 0);
         let _pq = (((inst >> 77) & 0x7) << 0);
         let _pu = (((inst >> 81) & 0x7) << 0);
         let _cop = (((inst >> 84) & 0x7) << 0);
@@ -3263,7 +3267,9 @@ impl<'a> Decoder<'a> {
         let _pg_not = (((inst >> 15) & 0x1) << 0);
         let _pr = (((inst >> 68) & 0x7) << 0);
         let _memdesc = (((inst >> 71) & 0x1) << 0);
-        let _lop = (((inst >> 72) & 0x1f) << 11) | (((inst >> 64) & 0x7) << 8) | (((inst >> 16) & 0xff) << 0);
+        let _lop = (((inst >> 72) & 0x1f) << 11)
+            | (((inst >> 64) & 0x7) << 8)
+            | (((inst >> 16) & 0xff) << 0);
         let _pq = (((inst >> 77) & 0x7) << 0);
         let _ftz = (((inst >> 80) & 0x1) << 0);
         let _pu = (((inst >> 81) & 0x7) << 0);
@@ -3309,7 +3315,9 @@ impl<'a> Decoder<'a> {
         let _pg = (((inst >> 12) & 0x7) << 0);
         let _pg_not = (((inst >> 15) & 0x1) << 0);
         let _pr = (((inst >> 68) & 0x7) << 0);
-        let _lop = (((inst >> 72) & 0x1f) << 11) | (((inst >> 64) & 0x7) << 8) | (((inst >> 16) & 0xff) << 0);
+        let _lop = (((inst >> 72) & 0x1f) << 11)
+            | (((inst >> 64) & 0x7) << 8)
+            | (((inst >> 16) & 0xff) << 0);
         let _pq = (((inst >> 77) & 0x7) << 0);
         let _pu = (((inst >> 81) & 0x7) << 0);
         let _cop = (((inst >> 84) & 0x7) << 0);

core/src/gpu/spirv.rs

@@ -2,13 +2,11 @@
 
 #[derive(Debug, Clone)]
 pub struct Emitter {
-    code: Vec<u32>
+    code: Vec<u32>,
 }
 impl Emitter {
     pub fn new() -> Self {
-        Self{
-            code: Vec::new(),
-        }
+        Self { code: Vec::new() }
     }
     pub fn emit_header(&mut self) {
         self.code.push(0x07230203);
@@ -80,7 +78,18 @@ impl Emitter {
         assert!(count >= 2);
         self.emit_generic(24, &[result, type_, count]);
     }
-    pub fn emit_type_image(&mut self, result: u32, type_: u32, dim: u32, depth: u32, arrayed: u32, ms: u32, sampled: u32, format: u32, acc_qual: &[u32]) {
+    pub fn emit_type_image(
+        &mut self,
+        result: u32,
+        type_: u32,
+        dim: u32,
+        depth: u32,
+        arrayed: u32,
+        ms: u32,
+        sampled: u32,
+        format: u32,
+        acc_qual: &[u32],
+    ) {
         assert!(depth <= 2);
         assert!(arrayed == 0 || arrayed == 1);
         assert!(ms == 0 || ms == 1);

core/src/gpu/test.rs

@@ -0,0 +1 @@
+

core/src/lib.rs

@@ -4,6 +4,6 @@ pub mod gpu;
 pub mod input;
 pub mod memory;
 pub mod mmu;
-pub mod tests;
 pub mod nn;
 pub mod sys;
+pub mod tests;

core/src/memory/memory.rs

@@ -1,6 +1,6 @@
 use crate::mmu::MMU;
-use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::Arc;
+use std::sync::atomic::{AtomicU64, Ordering};
 use std::thread;
 
 #[derive(Debug)]
@@ -31,7 +31,8 @@ impl ExclusiveMonitor {
         if current_addr == u64::MAX {
             self.monitored_address.store(addr, Ordering::Release);
             self.monitored_size.store(size, Ordering::Release);
-            self.owner_thread_id.store(Self::get_thread_id(), Ordering::Release);
+            self.owner_thread_id
+                .store(Self::get_thread_id(), Ordering::Release);
             true
         } else {
             false
@@ -48,17 +49,15 @@ impl ExclusiveMonitor {
         let monitored_addr = self.monitored_address.load(Ordering::Acquire);
         let monitored_size = self.monitored_size.load(Ordering::Acquire);
         let owner_thread_id = self.owner_thread_id.load(Ordering::Acquire);
-        
-        monitored_addr == addr && 
-        monitored_size == size && 
-        owner_thread_id == Self::get_thread_id()
+
+        monitored_addr == addr && monitored_size == size && owner_thread_id == Self::get_thread_id()
     }
 
     fn get_thread_id() -> u64 {
         let thread_id = thread::current().id();
-        use std::hash::{Hash, Hasher};
         use std::collections::hash_map::DefaultHasher;
-        
+        use std::hash::{Hash, Hasher};
+
         let mut hasher = DefaultHasher::new();
         thread_id.hash(&mut hasher);
         hasher.finish()
@@ -70,7 +69,7 @@ impl Memory {
         let mut mmu = MMU::new();
         let pages = (size + 4095) / 4096;
         mmu.set_identity_mapping(0, pages);
-        
+
         Memory {
             ram: vec![0; size],
             mmu,
@@ -81,15 +80,11 @@ impl Memory {
     pub fn map_range(&mut self, vaddr: usize, size: usize, readable: bool, writable: bool) {
         let start_page = vaddr / 4096;
         let end_page = (vaddr + size + 4095) / 4096;
-        
+
         for page in start_page..end_page {
             let vaddr = page * 4096;
-            self.mmu.map_page(
-                vaddr as u64,
-                vaddr as u64,
-                readable,
-                writable
-            );
+            self.mmu
+                .map_page(vaddr as u64, vaddr as u64, readable, writable);
         }
     }
 
@@ -130,7 +125,7 @@ impl Memory {
     pub fn read_u32(&mut self, addr: usize) -> u32 {
         let start_page = addr / 4096;
         let end_page = (addr + 3) / 4096;
-        
+
         if start_page != end_page {
             let mut bytes = [0u8; 4];
             for i in 0..4 {
@@ -138,7 +133,7 @@ impl Memory {
             }
             return u32::from_le_bytes(bytes);
         }
-        
+
         if let Some((paddr, _, _)) = self.mmu.translate(addr as u64) {
             let paddr = paddr as usize;
             if paddr + 3 < self.ram.len() {
@@ -159,7 +154,7 @@ impl Memory {
     pub fn write_u32(&mut self, addr: usize, value: u32) {
         let start_page = addr / 4096;
         let end_page = (addr + 3) / 4096;
-        
+
         if start_page != end_page {
             let bytes = value.to_le_bytes();
             for i in 0..4 {
@@ -167,7 +162,7 @@ impl Memory {
             }
             return;
         }
-        
+
         if let Some((paddr, _, _)) = self.mmu.translate(addr as u64) {
             let paddr = paddr as usize;
             if paddr + 3 < self.ram.len() {
@@ -315,7 +310,11 @@ impl Memory {
     }
 
     #[unsafe(no_mangle)]
-    pub extern "C" fn oboromi_memory_mark_exclusive(mem_ptr: *mut Memory, addr: u64, size: u64) -> bool {
+    pub extern "C" fn oboromi_memory_mark_exclusive(
+        mem_ptr: *mut Memory,
+        addr: u64,
+        size: u64,
+    ) -> bool {
         unsafe {
             if let Some(mem) = mem_ptr.as_ref() {
                 mem.mark_exclusive(addr, size)
@@ -335,7 +334,11 @@ impl Memory {
     }
 
     #[unsafe(no_mangle)]
-    pub extern "C" fn oboromi_memory_read_exclusive_u8(mem_ptr: *mut Memory, addr: u64, value: *mut u8) -> bool {
+    pub extern "C" fn oboromi_memory_read_exclusive_u8(
+        mem_ptr: *mut Memory,
+        addr: u64,
+        value: *mut u8,
+    ) -> bool {
         unsafe {
             if let Some(mem) = mem_ptr.as_mut() {
                 if mem.mark_exclusive(addr, 1) {
@@ -351,7 +354,11 @@ impl Memory {
     }
 
     #[unsafe(no_mangle)]
-    pub extern "C" fn oboromi_memory_write_exclusive_u8(mem_ptr: *mut Memory, addr: u64, value: u8) -> bool {
+    pub extern "C" fn oboromi_memory_write_exclusive_u8(
+        mem_ptr: *mut Memory,
+        addr: u64,
+        value: u8,
+    ) -> bool {
         unsafe {
             if let Some(mem) = mem_ptr.as_mut() {
                 mem.exclusive_write_u8(addr, value)

core/src/mmu/mmu.rs

@@ -22,16 +22,16 @@ impl MMU {
         if let Some(result) = self.tlb.lookup(vaddr) {
             return Some(result);
         }
-        
+
         // 2. Page table walk
         let (paddr, readable, writable) = self.page_table.walk(vaddr)?;
-        
+
         // 3. Update TLB
         self.tlb.add_entry(vaddr, paddr, readable, writable);
-        
+
         Some((paddr, readable, writable))
     }
-    
+
     /// Set identity mapping for a memory range with permissions
     pub fn set_identity_mapping(&mut self, start_page: usize, page_count: usize) {
         for i in 0..page_count {
@@ -39,17 +39,18 @@ impl MMU {
             self.page_table.set_entry(
                 page_index,
                 (page_index * 4096) as u64,
-                true,  // Readable
-                true   // Writable
+                true, // Readable
+                true, // Writable
             );
         }
     }
-    
+
     /// Map a single page from virtual to physical address with permissions
     pub fn map_page(&mut self, vaddr: u64, paddr: u64, readable: bool, writable: bool) {
         let vpn = (vaddr >> 12) as usize;
         let aligned_paddr = paddr & !0xFFF;
-        self.page_table.set_entry(vpn, aligned_paddr, readable, writable);
+        self.page_table
+            .set_entry(vpn, aligned_paddr, readable, writable);
         self.tlb.invalidate(vaddr);
     }
-}
+}

core/src/mmu/mod.rs

@@ -2,4 +2,4 @@ pub mod mmu;
 pub mod paging;
 pub mod tlb;
 
-pub use mmu::MMU;
+pub use mmu::MMU;

core/src/mmu/paging.rs

@@ -18,21 +18,25 @@ impl PageTable {
     pub fn walk(&self, vaddr: u64) -> Option<(u64, bool, bool)> {
         let vpn = (vaddr >> 12) as usize;
         let (base, permissions) = self.entries.get(&vpn)?;
-        
+
         // Physical address = page base + offset
         Some((
             base | (vaddr & 0xFFF),
             permissions & (1 << 62) != 0,
-            permissions & (1 << 63) != 0
+            permissions & (1 << 63) != 0,
         ))
     }
 
     /// Set a page table entry with permissions
     pub fn set_entry(&mut self, index: usize, value: u64, readable: bool, writable: bool) {
         let mut perm_flags = 0u64;
-        if readable { perm_flags |= 1 << 62; }
-        if writable { perm_flags |= 1 << 63; }
-        
+        if readable {
+            perm_flags |= 1 << 62;
+        }
+        if writable {
+            perm_flags |= 1 << 63;
+        }
+
         self.entries.insert(index, (value, perm_flags));
     }
 
@@ -40,4 +44,4 @@ impl PageTable {
     pub fn as_ptr(&self) -> *const std::ffi::c_void {
         self as *const _ as *const std::ffi::c_void
     }
-}
+}

core/src/mmu/tlb.rs

@@ -40,13 +40,13 @@ impl Tlb {
     /// Lookup virtual address in TLB with permissions
     pub fn lookup(&self, vaddr: u64) -> Option<(u64, bool, bool)> {
         let aligned_vaddr = vaddr & !0xFFF;
-        
+
         for entry in &self.entries {
             if entry.valid && entry.vaddr == aligned_vaddr {
                 return Some((
                     entry.paddr | (vaddr & 0xFFF),
                     entry.readable,
-                    entry.writable
+                    entry.writable,
                 ));
             }
         }
@@ -66,7 +66,7 @@ impl Tlb {
             aligned_vaddr,
             aligned_paddr,
             readable,
-            writable
+            writable,
         ));
     }
 
@@ -75,4 +75,4 @@ impl Tlb {
         let aligned_vaddr = vaddr & !0xFFF;
         self.entries.retain(|entry| entry.vaddr != aligned_vaddr);
     }
-}
+}

core/src/nn/acc.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.acc = Some(State::new(state));
     }
 }

core/src/nn/adraw.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.adraw = Some(State::new(state));
     }
 }

core/src/nn/ahid.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.ahid = Some(State::new(state));
     }
 }

core/src/nn/aoc.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.aoc = Some(State::new(state));
     }
 }

core/src/nn/apm.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.apm = Some(State::new(state));
     }
 }

core/src/nn/applet_ae.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.applet_ae = Some(State::new(state));
     }
 }

core/src/nn/applet_oe.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.applet_oe = Some(State::new(state));
     }
 }

core/src/nn/arp.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.arp = Some(State::new(state));
     }
 }

core/src/nn/aud.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.aud = Some(State::new(state));
     }
 }

core/src/nn/audctl.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.audctl = Some(State::new(state));
     }
 }

core/src/nn/auddebug.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.auddebug = Some(State::new(state));
     }
 }

core/src/nn/auddev.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.auddev = Some(State::new(state));
     }
 }

core/src/nn/auddmg.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.auddmg = Some(State::new(state));
     }
 }

core/src/nn/audin.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.audin = Some(State::new(state));
     }
 }

core/src/nn/audout.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.audout = Some(State::new(state));
     }
 }

core/src/nn/audrec.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.audrec = Some(State::new(state));
     }
 }

core/src/nn/audren.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.audren = Some(State::new(state));
     }
 }

core/src/nn/audsmx.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.audsmx = Some(State::new(state));
     }
 }

core/src/nn/avm.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.avm = Some(State::new(state));
     }
 }

core/src/nn/banana.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.banana = Some(State::new(state));
     }
 }

core/src/nn/batlog.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.batlog = Some(State::new(state));
     }
 }

core/src/nn/bcat.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.bcat = Some(State::new(state));
     }
 }

core/src/nn/bgtc.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.bgtc = Some(State::new(state));
     }
 }

core/src/nn/bpc.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.bpc = Some(State::new(state));
     }
 }

core/src/nn/bpmpmr.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.bpmpmr = Some(State::new(state));
     }
 }

core/src/nn/bsd.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.bsd = Some(State::new(state));
     }
 }

core/src/nn/bsdcfg.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.bsdcfg = Some(State::new(state));
     }
 }

core/src/nn/bt.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.bt = Some(State::new(state));
     }
 }

core/src/nn/btdrv.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.btdrv = Some(State::new(state));
     }
 }

core/src/nn/btm.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.btm = Some(State::new(state));
     }
 }

core/src/nn/btp.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.btp = Some(State::new(state));
     }
 }

core/src/nn/capmtp.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.capmtp = Some(State::new(state));
     }
 }

core/src/nn/caps.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.caps = Some(State::new(state));
     }
 }

core/src/nn/caps2.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.caps2 = Some(State::new(state));
     }
 }

core/src/nn/cec_mgr.rs

@@ -1,11 +1,9 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {

core/src/nn/chat.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.chat = Some(State::new(state));
     }
 }

core/src/nn/clkrst.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.clkrst = Some(State::new(state));
     }
 }

core/src/nn/codecctl.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.codecctl = Some(State::new(state));
     }
 }

core/src/nn/csrng.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.csrng = Some(State::new(state));
     }
 }

core/src/nn/dauth.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.dauth = Some(State::new(state));
     }
 }

core/src/nn/disp.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.disp = Some(State::new(state));
     }
 }

core/src/nn/dispdrv.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.dispdrv = Some(State::new(state));
     }
 }

core/src/nn/dmnt.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.dmnt = Some(State::new(state));
     }
 }

core/src/nn/dns.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.dns = Some(State::new(state));
     }
 }

core/src/nn/dt.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.dt = Some(State::new(state));
     }
 }

core/src/nn/ectx.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.ectx = Some(State::new(state));
     }
 }

core/src/nn/erpt.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.erpt = Some(State::new(state));
     }
 }

core/src/nn/es.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.es = Some(State::new(state));
     }
 }

core/src/nn/eth.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.eth = Some(State::new(state));
     }
 }

core/src/nn/ethc.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.ethc = Some(State::new(state));
     }
 }

core/src/nn/eupld.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.eupld = Some(State::new(state));
     }
 }

core/src/nn/fan.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.fan = Some(State::new(state));
     }
 }

core/src/nn/fatal.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.fatal = Some(State::new(state));
     }
 }

core/src/nn/fgm.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.fgm = Some(State::new(state));
     }
 }

core/src/nn/file_io.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.file_io = Some(State::new(state));
     }
 }

core/src/nn/friend.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.friend = Some(State::new(state));
     }
 }

core/src/nn/fs.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.fs = Some(State::new(state));
     }
 }

core/src/nn/fsp_ldr.rs

@@ -1,11 +1,9 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {

core/src/nn/fsp_pr.rs

@@ -1,11 +1,9 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {

core/src/nn/fsp_srv.rs

@@ -1,11 +1,9 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {

core/src/nn/gds.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.gds = Some(State::new(state));
     }
 }

core/src/nn/gpio.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.gpio = Some(State::new(state));
     }
 }

core/src/nn/gpuk.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.gpuk = Some(State::new(state));
     }
 }

core/src/nn/grc.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.grc = Some(State::new(state));
     }
 }

core/src/nn/gsv.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.gsv = Some(State::new(state));
     }
 }

core/src/nn/hdcp.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.hdcp = Some(State::new(state));
     }
 }

core/src/nn/hid.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.hid = Some(State::new(state));
     }
 }

core/src/nn/hidbus.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.hidbus = Some(State::new(state));
     }
 }

core/src/nn/host1x.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.host1x = Some(State::new(state));
     }
 }

core/src/nn/hshl.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.hshl = Some(State::new(state));
     }
 }

core/src/nn/htc.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.htc = Some(State::new(state));
     }
 }

core/src/nn/htcs.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.htcs = Some(State::new(state));
     }
 }

core/src/nn/hwopus.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.hwopus = Some(State::new(state));
     }
 }

core/src/nn/i2c.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.i2c = Some(State::new(state));
     }
 }

core/src/nn/idle.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.idle = Some(State::new(state));
     }
 }

core/src/nn/ifcfg.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.ifcfg = Some(State::new(state));
     }
 }

core/src/nn/imf.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.imf = Some(State::new(state));
     }
 }

core/src/nn/ins.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.ins = Some(State::new(state));
     }
 }

core/src/nn/irs.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.irs = Some(State::new(state));
     }
 }

core/src/nn/jit.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.jit = Some(State::new(state));
     }
 }

core/src/nn/lbl.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.lbl = Some(State::new(state));
     }
 }

core/src/nn/ldn.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.ldn = Some(State::new(state));
     }
 }

core/src/nn/ldr.rs

@@ -1,15 +1,13 @@
-use crate::sys;
 use crate::nn::ServiceTrait;
-pub struct State {
-
-}
+use crate::sys;
+pub struct State {}
 impl State {
     pub fn new(_state: &mut sys::State) -> Self {
-        Self{}
+        Self {}
     }
 }
 impl ServiceTrait for State {
-     fn run(state: &mut sys::State) {
+    fn run(state: &mut sys::State) {
         state.services.ldr = Some(State::new(state));
     }
 }