Compile time explosion in device-driver

compile_time_explosion.rs

#!/usr/bin/env cargo
---
[package]
edition = "2024"
[dependencies]
device-driver = { path="../../../device-driver", default-features=false }
---
#![deny(warnings)]
fn main() {}

// rustfmt exited unsuccesfully (exit code: 0xc00000fd):
// 
// thread 'main' has overflowed its stack


    

    


/// Root block of the Device driver

#[derive(Debug)]
pub struct Device<I> {
    
    pub(crate) interface: I,
    
    #[doc(hidden)]
    base_address: u32,
}


impl<I> Device<I> {
    
    /// Create a new instance of the block based on device interface
    pub const fn new(interface: I) -> Self {
        Self { interface, base_address: 0 }
    }

    /// A reference to the interface used to communicate with the device
    pub(crate) fn interface(&mut self) -> &mut I {
        &mut self.interface
    }
    

    /// Read all readable register values in this block from the device.
    /// The callback is called for each of them.
    /// Any registers in child blocks are not included.
    ///
    /// The callback has three arguments:
    ///
    /// - The address of the register
    /// - The name of the register (with index for repeated registers)
    /// - The read value from the register
    ///
    /// This is useful for e.g. debug printing all values.
    /// The given [field_sets::FieldSetValue] has a Debug and Format implementation that forwards to the concrete type
    /// the lies within so it can be printed without matching on it.
    #[allow(unused_mut)]
    #[allow(unused_variables)]
    pub fn read_all_registers(
        &mut self,
        mut callback: impl FnMut(u32, &'static str, field_sets::FieldSetValue),
    ) -> Result<(), I::Error>
    where
        I: ::device_driver::RegisterInterface<AddressType = u32>,
    {
        
            
                
                    
                            
                                
                                let reg = self.foo_0(0).read()?;
                                
                                callback(0 + 0 * 1000, "foo_0[0]", reg.into());
                            
                                
                                let reg = self.foo_0(1).read()?;
                                
                                callback(0 + 1 * 1000, "foo_0[1]", reg.into());
                            
                                
                                let reg = self.foo_0(2).read()?;
                                
                                callback(0 + 2 * 1000, "foo_0[2]", reg.into());
                            
                                
                                let reg = self.foo_0(3).read()?;
                                
                                callback(0 + 3 * 1000, "foo_0[3]", reg.into());
                            
                                
                                let reg = self.foo_0(4).read()?;
                                
                                callback(0 + 4 * 1000, "foo_0[4]", reg.into());
                            
                                
                                let reg = self.foo_0(5).read()?;
                                
                                callback(0 + 5 * 1000, "foo_0[5]", reg.into());
                            
                                
                                let reg = self.foo_0(6).read()?;
                                
                                callback(0 + 6 * 1000, "foo_0[6]", reg.into());
                            
                                
                                let reg = self.foo_0(7).read()?;
                                
                                callback(0 + 7 * 1000, "foo_0[7]", reg.into());
                            
                                
                                let reg = self.foo_0(8).read()?;
                                
                                callback(0 + 8 * 1000, "foo_0[8]", reg.into());
                            
                                
                                let reg = self.foo_0(9).read()?;
                                
                                callback(0 + 9 * 1000, "foo_0[9]", reg.into());
                            
                                
                                let reg = self.foo_0(10).read()?;
                                
                                callback(0 + 10 * 1000, "foo_0[10]", reg.into());
                            
                                
                                let reg = self.foo_0(11).read()?;
                                
                                callback(0 + 11 * 1000, "foo_0[11]", reg.into());
                            
                                
                                let reg = self.foo_0(12).read()?;
                                
                                callback(0 + 12 * 1000, "foo_0[12]", reg.into());
                            
                                
                                let reg = self.foo_0(13).read()?;
                                
                                callback(0 + 13 * 1000, "foo_0[13]", reg.into());
                            
                                
                                let reg = self.foo_0(14).read()?;
                                
                                callback(0 + 14 * 1000, "foo_0[14]", reg.into());
                            
                                
                                let reg = self.foo_0(15).read()?;
                                
                                callback(0 + 15 * 1000, "foo_0[15]", reg.into());
                            
                                
                                let reg = self.foo_0(16).read()?;
                                
                                callback(0 + 16 * 1000, "foo_0[16]", reg.into());
                            
                                
                                let reg = self.foo_0(17).read()?;
                                
                                callback(0 + 17 * 1000, "foo_0[17]", reg.into());
                            
                                
                                let reg = self.foo_0(18).read()?;
                                
                                callback(0 + 18 * 1000, "foo_0[18]", reg.into());
                            
                                
                                let reg = self.foo_0(19).read()?;
                                
                                callback(0 + 19 * 1000, "foo_0[19]", reg.into());
                            
                                
                                let reg = self.foo_0(20).read()?;
                                
                                callback(0 + 20 * 1000, "foo_0[20]", reg.into());
                            
                                
                                let reg = self.foo_0(21).read()?;
                                
                                callback(0 + 21 * 1000, "foo_0[21]", reg.into());
                            
                                
                                let reg = self.foo_0(22).read()?;
                                
                                callback(0 + 22 * 1000, "foo_0[22]", reg.into());
                            
                                
                                let reg = self.foo_0(23).read()?;
                                
                                callback(0 + 23 * 1000, "foo_0[23]", reg.into());
                            
                                
                                let reg = self.foo_0(24).read()?;
                                
                                callback(0 + 24 * 1000, "foo_0[24]", reg.into());
                            
                                
                                let reg = self.foo_0(25).read()?;
                                
                                callback(0 + 25 * 1000, "foo_0[25]", reg.into());
                            
                                
                                let reg = self.foo_0(26).read()?;
                                
                                callback(0 + 26 * 1000, "foo_0[26]", reg.into());
                            
                                
                                let reg = self.foo_0(27).read()?;
                                
                                callback(0 + 27 * 1000, "foo_0[27]", reg.into());
                            
                                
                                let reg = self.foo_0(28).read()?;
                                
                                callback(0 + 28 * 1000, "foo_0[28]", reg.into());
                            
                                
                                let reg = self.foo_0(29).read()?;
                                
                                callback(0 + 29 * 1000, "foo_0[29]", reg.into());
                            
                                
                                let reg = self.foo_0(30).read()?;
                                
                                callback(0 + 30 * 1000, "foo_0[30]", reg.into());
                            
                                
                                let reg = self.foo_0(31).read()?;
                                
                                callback(0 + 31 * 1000, "foo_0[31]", reg.into());
                            
                                
                                let reg = self.foo_0(32).read()?;
                                
                                callback(0 + 32 * 1000, "foo_0[32]", reg.into());
                            
                                
                                let reg = self.foo_0(33).read()?;
                                
                                callback(0 + 33 * 1000, "foo_0[33]", reg.into());
                            
                                
                                let reg = self.foo_0(34).read()?;
                                
                                callback(0 + 34 * 1000, "foo_0[34]", reg.into());
                            
                                
                                let reg = self.foo_0(35).read()?;
                                
                                callback(0 + 35 * 1000, "foo_0[35]", reg.into());
                            
                                
                                let reg = self.foo_0(36).read()?;
                                
                                callback(0 + 36 * 1000, "foo_0[36]", reg.into());
                            
                                
                                let reg = self.foo_0(37).read()?;
                                
                                callback(0 + 37 * 1000, "foo_0[37]", reg.into());
                            
                                
                                let reg = self.foo_0(38).read()?;
                                
                                callback(0 + 38 * 1000, "foo_0[38]", reg.into());
                            
                                
                                let reg = self.foo_0(39).read()?;
                                
                                callback(0 + 39 * 1000, "foo_0[39]", reg.into());
                            
                                
                                let reg = self.foo_0(40).read()?;
                                
                                callback(0 + 40 * 1000, "foo_0[40]", reg.into());
                            
                                
                                let reg = self.foo_0(41).read()?;
                                
                                callback(0 + 41 * 1000, "foo_0[41]", reg.into());
                            
                                
                                let reg = self.foo_0(42).read()?;
                                
                                callback(0 + 42 * 1000, "foo_0[42]", reg.into());
                            
                                
                                let reg = self.foo_0(43).read()?;
                                
                                callback(0 + 43 * 1000, "foo_0[43]", reg.into());
                            
                                
                                let reg = self.foo_0(44).read()?;
                                
                                callback(0 + 44 * 1000, "foo_0[44]", reg.into());
                            
                                
                                let reg = self.foo_0(45).read()?;
                                
                                callback(0 + 45 * 1000, "foo_0[45]", reg.into());
                            
                                
                                let reg = self.foo_0(46).read()?;
                                
                                callback(0 + 46 * 1000, "foo_0[46]", reg.into());
                            
                                
                                let reg = self.foo_0(47).read()?;
                                
                                callback(0 + 47 * 1000, "foo_0[47]", reg.into());
                            
                                
                                let reg = self.foo_0(48).read()?;
                                
                                callback(0 + 48 * 1000, "foo_0[48]", reg.into());
                            
                                
                                let reg = self.foo_0(49).read()?;
                                
                                callback(0 + 49 * 1000, "foo_0[49]", reg.into());
                            
                                
                                let reg = self.foo_0(50).read()?;
                                
                                callback(0 + 50 * 1000, "foo_0[50]", reg.into());
                            
                                
                                let reg = self.foo_0(51).read()?;
                                
                                callback(0 + 51 * 1000, "foo_0[51]", reg.into());
                            
                                
                                let reg = self.foo_0(52).read()?;
                                
                                callback(0 + 52 * 1000, "foo_0[52]", reg.into());
                            
                                
                                let reg = self.foo_0(53).read()?;
                                
                                callback(0 + 53 * 1000, "foo_0[53]", reg.into());
                            
                                
                                let reg = self.foo_0(54).read()?;
                                
                                callback(0 + 54 * 1000, "foo_0[54]", reg.into());
                            
                                
                                let reg = self.foo_0(55).read()?;
                                
                                callback(0 + 55 * 1000, "foo_0[55]", reg.into());
                            
                                
                                let reg = self.foo_0(56).read()?;
                                
                                callback(0 + 56 * 1000, "foo_0[56]", reg.into());
                            
                                
                                let reg = self.foo_0(57).read()?;
                                
                                callback(0 + 57 * 1000, "foo_0[57]", reg.into());
                            
                                
                                let reg = self.foo_0(58).read()?;
                                
                                callback(0 + 58 * 1000, "foo_0[58]", reg.into());
                            
                                
                                let reg = self.foo_0(59).read()?;
                                
                                callback(0 + 59 * 1000, "foo_0[59]", reg.into());
                            
                                
                                let reg = self.foo_0(60).read()?;
                                
                                callback(0 + 60 * 1000, "foo_0[60]", reg.into());
                            
                                
                                let reg = self.foo_0(61).read()?;
                                
                                callback(0 + 61 * 1000, "foo_0[61]", reg.into());
                            
                                
                                let reg = self.foo_0(62).read()?;
                                
                                callback(0 + 62 * 1000, "foo_0[62]", reg.into());
                            
                                
                                let reg = self.foo_0(63).read()?;
                                
                                callback(0 + 63 * 1000, "foo_0[63]", reg.into());
                            
                                
                                let reg = self.foo_0(64).read()?;
                                
                                callback(0 + 64 * 1000, "foo_0[64]", reg.into());
                            
                                
                                let reg = self.foo_0(65).read()?;
                                
                                callback(0 + 65 * 1000, "foo_0[65]", reg.into());
                            
                                
                                let reg = self.foo_0(66).read()?;
                                
                                callback(0 + 66 * 1000, "foo_0[66]", reg.into());
                            
                                
                                let reg = self.foo_0(67).read()?;
                                
                                callback(0 + 67 * 1000, "foo_0[67]", reg.into());
                            
                                
                                let reg = self.foo_0(68).read()?;
                                
                                callback(0 + 68 * 1000, "foo_0[68]", reg.into());
                            
                                
                                let reg = self.foo_0(69).read()?;
                                
                                callback(0 + 69 * 1000, "foo_0[69]", reg.into());
                            
                                
                                let reg = self.foo_0(70).read()?;
                                
                                callback(0 + 70 * 1000, "foo_0[70]", reg.into());
                            
                                
                                let reg = self.foo_0(71).read()?;
                                
                                callback(0 + 71 * 1000, "foo_0[71]", reg.into());
                            
                                
                                let reg = self.foo_0(72).read()?;
                                
                                callback(0 + 72 * 1000, "foo_0[72]", reg.into());
                            
                                
                                let reg = self.foo_0(73).read()?;
                                
                                callback(0 + 73 * 1000, "foo_0[73]", reg.into());
                            
                                
                                let reg = self.foo_0(74).read()?;
                                
                                callback(0 + 74 * 1000, "foo_0[74]", reg.into());
                            
                                
                                let reg = self.foo_0(75).read()?;
                                
                                callback(0 + 75 * 1000, "foo_0[75]", reg.into());
                            
                                
                                let reg = self.foo_0(76).read()?;
                                
                                callback(0 + 76 * 1000, "foo_0[76]", reg.into());
                            
                                
                                let reg = self.foo_0(77).read()?;
                                
                                callback(0 + 77 * 1000, "foo_0[77]", reg.into());
                            
                                
                                let reg = self.foo_0(78).read()?;
                                
                                callback(0 + 78 * 1000, "foo_0[78]", reg.into());
                            
                                
                                let reg = self.foo_0(79).read()?;
                                
                                callback(0 + 79 * 1000, "foo_0[79]", reg.into());
                            
                                
                                let reg = self.foo_0(80).read()?;
                                
                                callback(0 + 80 * 1000, "foo_0[80]", reg.into());
                            
                                
                                let reg = self.foo_0(81).read()?;
                                
                                callback(0 + 81 * 1000, "foo_0[81]", reg.into());
                            
                                
                                let reg = self.foo_0(82).read()?;
                                
                                callback(0 + 82 * 1000, "foo_0[82]", reg.into());
                            
                                
                                let reg = self.foo_0(83).read()?;
                                
                                callback(0 + 83 * 1000, "foo_0[83]", reg.into());
                            
                                
                                let reg = self.foo_0(84).read()?;
                                
                                callback(0 + 84 * 1000, "foo_0[84]", reg.into());
                            
                                
                                let reg = self.foo_0(85).read()?;
                                
                                callback(0 + 85 * 1000, "foo_0[85]", reg.into());
                            
                                
                                let reg = self.foo_0(86).read()?;
                                
                                callback(0 + 86 * 1000, "foo_0[86]", reg.into());
                            
                                
                                let reg = self.foo_0(87).read()?;
                                
                                callback(0 + 87 * 1000, "foo_0[87]", reg.into());
                            
                                
                                let reg = self.foo_0(88).read()?;
                                
                                callback(0 + 88 * 1000, "foo_0[88]", reg.into());
                            
                                
                                let reg = self.foo_0(89).read()?;
                                
                                callback(0 + 89 * 1000, "foo_0[89]", reg.into());
                            
                                
                                let reg = self.foo_0(90).read()?;
                                
                                callback(0 + 90 * 1000, "foo_0[90]", reg.into());
                            
                                
                                let reg = self.foo_0(91).read()?;
                                
                                callback(0 + 91 * 1000, "foo_0[91]", reg.into());
                            
                                
                                let reg = self.foo_0(92).read()?;
                                
                                callback(0 + 92 * 1000, "foo_0[92]", reg.into());
                            
                                
                                let reg = self.foo_0(93).read()?;
                                
                                callback(0 + 93 * 1000, "foo_0[93]", reg.into());
                            
                                
                                let reg = self.foo_0(94).read()?;
                                
                                callback(0 + 94 * 1000, "foo_0[94]", reg.into());
                            
                                
                                let reg = self.foo_0(95).read()?;
                                
                                callback(0 + 95 * 1000, "foo_0[95]", reg.into());
                            
                                
                                let reg = self.foo_0(96).read()?;
                                
                                callback(0 + 96 * 1000, "foo_0[96]", reg.into());
                            
                                
                                let reg = self.foo_0(97).read()?;
                                
                                callback(0 + 97 * 1000, "foo_0[97]", reg.into());
                            
                                
                                let reg = self.foo_0(98).read()?;
                                
                                callback(0 + 98 * 1000, "foo_0[98]", reg.into());
                            
                                
                                let reg = self.foo_0(99).read()?;
                                
                                callback(0 + 99 * 1000, "foo_0[99]", reg.into());
                            
                        
                
            
        
            
                
                    
                            
                                
                                let reg = self.foo_1(0).read()?;
                                
                                callback(1 + 0 * 1000, "foo_1[0]", reg.into());
                            
                                
                                let reg = self.foo_1(1).read()?;
                                
                                callback(1 + 1 * 1000, "foo_1[1]", reg.into());
                            
                                
                                let reg = self.foo_1(2).read()?;
                                
                                callback(1 + 2 * 1000, "foo_1[2]", reg.into());
                            
                                
                                let reg = self.foo_1(3).read()?;
                                
                                callback(1 + 3 * 1000, "foo_1[3]", reg.into());
                            
                                
                                let reg = self.foo_1(4).read()?;
                                
                                callback(1 + 4 * 1000, "foo_1[4]", reg.into());
                            
                                
                                let reg = self.foo_1(5).read()?;
                                
                                callback(1 + 5 * 1000, "foo_1[5]", reg.into());
                            
                                
                                let reg = self.foo_1(6).read()?;
                                
                                callback(1 + 6 * 1000, "foo_1[6]", reg.into());
                            
                                
                                let reg = self.foo_1(7).read()?;
                                
                                callback(1 + 7 * 1000, "foo_1[7]", reg.into());
                            
                                
                                let reg = self.foo_1(8).read()?;
                                
                                callback(1 + 8 * 1000, "foo_1[8]", reg.into());
                            
                                
                                let reg = self.foo_1(9).read()?;
                                
                                callback(1 + 9 * 1000, "foo_1[9]", reg.into());
                            
                                
                                let reg = self.foo_1(10).read()?;
                                
                                callback(1 + 10 * 1000, "foo_1[10]", reg.into());
                            
                                
                                let reg = self.foo_1(11).read()?;
                                
                                callback(1 + 11 * 1000, "foo_1[11]", reg.into());
                            
                                
                                let reg = self.foo_1(12).read()?;
                                
                                callback(1 + 12 * 1000, "foo_1[12]", reg.into());
                            
                                
                                let reg = self.foo_1(13).read()?;
                                
                                callback(1 + 13 * 1000, "foo_1[13]", reg.into());
                            
                                
                                let reg = self.foo_1(14).read()?;
                                
                                callback(1 + 14 * 1000, "foo_1[14]", reg.into());
                            
                                
                                let reg = self.foo_1(15).read()?;
                                
                                callback(1 + 15 * 1000, "foo_1[15]", reg.into());
                            
                                
                                let reg = self.foo_1(16).read()?;
                                
                                callback(1 + 16 * 1000, "foo_1[16]", reg.into());
                            
                                
                                let reg = self.foo_1(17).read()?;
                                
                                callback(1 + 17 * 1000, "foo_1[17]", reg.into());
                            
                                
                                let reg = self.foo_1(18).read()?;
                                
                                callback(1 + 18 * 1000, "foo_1[18]", reg.into());
                            
                                
                                let reg = self.foo_1(19).read()?;
                                
                                callback(1 + 19 * 1000, "foo_1[19]", reg.into());
                            
                                
                                let reg = self.foo_1(20).read()?;
                                
                                callback(1 + 20 * 1000, "foo_1[20]", reg.into());
                            
                                
                                let reg = self.foo_1(21).read()?;
                                
                                callback(1 + 21 * 1000, "foo_1[21]", reg.into());
                            
                                
                                let reg = self.foo_1(22).read()?;
                                
                                callback(1 + 22 * 1000, "foo_1[22]", reg.into());
                            
                                
                                let reg = self.foo_1(23).read()?;
                                
                                callback(1 + 23 * 1000, "foo_1[23]", reg.into());
                            
                                
                                let reg = self.foo_1(24).read()?;
                                
                                callback(1 + 24 * 1000, "foo_1[24]", reg.into());
                            
                                
                                let reg = self.foo_1(25).read()?;
                                
                                callback(1 + 25 * 1000, "foo_1[25]", reg.into());
                            
                                
                                let reg = self.foo_1(26).read()?;
                                
                                callback(1 + 26 * 1000, "foo_1[26]", reg.into());
                            
                                
                                let reg = self.foo_1(27).read()?;
                                
                                callback(1 + 27 * 1000, "foo_1[27]", reg.into());
                            
                                
                                let reg = self.foo_1(28).read()?;
                                
                                callback(1 + 28 * 1000, "foo_1[28]", reg.into());
                            
                                
                                let reg = self.foo_1(29).read()?;
                                
                                callback(1 + 29 * 1000, "foo_1[29]", reg.into());
                            
                                
                                let reg = self.foo_1(30).read()?;
                                
                                callback(1 + 30 * 1000, "foo_1[30]", reg.into());
                            
                                
                                let reg = self.foo_1(31).read()?;
                                
                                callback(1 + 31 * 1000, "foo_1[31]", reg.into());
                            
                                
                                let reg = self.foo_1(32).read()?;
                                
                                callback(1 + 32 * 1000, "foo_1[32]", reg.into());
                            
                                
                                let reg = self.foo_1(33).read()?;
                                
                                callback(1 + 33 * 1000, "foo_1[33]", reg.into());
                            
                                
                                let reg = self.foo_1(34).read()?;
                                
                                callback(1 + 34 * 1000, "foo_1[34]", reg.into());
                            
                                
                                let reg = self.foo_1(35).read()?;
                                
                                callback(1 + 35 * 1000, "foo_1[35]", reg.into());
                            
                                
                                let reg = self.foo_1(36).read()?;
                                
                                callback(1 + 36 * 1000, "foo_1[36]", reg.into());
                            
                                
                                let reg = self.foo_1(37).read()?;
                                
                                callback(1 + 37 * 1000, "foo_1[37]", reg.into());
                            
                                
                                let reg = self.foo_1(38).read()?;
                                
                                callback(1 + 38 * 1000, "foo_1[38]", reg.into());
                            
                                
                                let reg = self.foo_1(39).read()?;
                                
                                callback(1 + 39 * 1000, "foo_1[39]", reg.into());
                            
                                
                                let reg = self.foo_1(40).read()?;
                                
                                callback(1 + 40 * 1000, "foo_1[40]", reg.into());
                            
                                
                                let reg = self.foo_1(41).read()?;
                                
                                callback(1 + 41 * 1000, "foo_1[41]", reg.into());
                            
                                
                                let reg = self.foo_1(42).read()?;
                                
                                callback(1 + 42 * 1000, "foo_1[42]", reg.into());
                            
                                
                                let reg = self.foo_1(43).read()?;
                                
                                callback(1 + 43 * 1000, "foo_1[43]", reg.into());
                            
                                
                                let reg = self.foo_1(44).read()?;
                                
                                callback(1 + 44 * 1000, "foo_1[44]", reg.into());
                            
                                
                                let reg = self.foo_1(45).read()?;
                                
                                callback(1 + 45 * 1000, "foo_1[45]", reg.into());
                            
                                
                                let reg = self.foo_1(46).read()?;
                                
                                callback(1 + 46 * 1000, "foo_1[46]", reg.into());
                            
                                
                                let reg = self.foo_1(47).read()?;
                                
                                callback(1 + 47 * 1000, "foo_1[47]", reg.into());
                            
                                
                                let reg = self.foo_1(48).read()?;
                                
                                callback(1 + 48 * 1000, "foo_1[48]", reg.into());
                            
                                
                                let reg = self.foo_1(49).read()?;
                                
                                callback(1 + 49 * 1000, "foo_1[49]", reg.into());
                            
                                
                                let reg = self.foo_1(50).read()?;
                                
                                callback(1 + 50 * 1000, "foo_1[50]", reg.into());
                            
                                
                                let reg = self.foo_1(51).read()?;
                                
                                callback(1 + 51 * 1000, "foo_1[51]", reg.into());
                            
                                
                                let reg = self.foo_1(52).read()?;
                                
                                callback(1 + 52 * 1000, "foo_1[52]", reg.into());
                            
                                
                                let reg = self.foo_1(53).read()?;
                                
                                callback(1 + 53 * 1000, "foo_1[53]", reg.into());
                            
                                
                                let reg = self.foo_1(54).read()?;
                                
                                callback(1 + 54 * 1000, "foo_1[54]", reg.into());
                            
                                
                                let reg = self.foo_1(55).read()?;
                                
                                callback(1 + 55 * 1000, "foo_1[55]", reg.into());
                            
                                
                                let reg = self.foo_1(56).read()?;
                                
                                callback(1 + 56 * 1000, "foo_1[56]", reg.into());
                            
                                
                                let reg = self.foo_1(57).read()?;
                                
                                callback(1 + 57 * 1000, "foo_1[57]", reg.into());
                            
                                
                                let reg = self.foo_1(58).read()?;
                                
                                callback(1 + 58 * 1000, "foo_1[58]", reg.into());
                            
                                
                                let reg = self.foo_1(59).read()?;
                                
                                callback(1 + 59 * 1000, "foo_1[59]", reg.into());
                            
                                
                                let reg = self.foo_1(60).read()?;
                                
                                callback(1 + 60 * 1000, "foo_1[60]", reg.into());
                            
                                
                                let reg = self.foo_1(61).read()?;
                                
                                callback(1 + 61 * 1000, "foo_1[61]", reg.into());
                            
                                
                                let reg = self.foo_1(62).read()?;
                                
                                callback(1 + 62 * 1000, "foo_1[62]", reg.into());
                            
                                
                                let reg = self.foo_1(63).read()?;
                                
                                callback(1 + 63 * 1000, "foo_1[63]", reg.into());
                            
                                
                                let reg = self.foo_1(64).read()?;
                                
                                callback(1 + 64 * 1000, "foo_1[64]", reg.into());
                            
                                
                                let reg = self.foo_1(65).read()?;
                                
                                callback(1 + 65 * 1000, "foo_1[65]", reg.into());
                            
                                
                                let reg = self.foo_1(66).read()?;
                                
                                callback(1 + 66 * 1000, "foo_1[66]", reg.into());
                            
                                
                                let reg = self.foo_1(67).read()?;
                                
                                callback(1 + 67 * 1000, "foo_1[67]", reg.into());
                            
                                
                                let reg = self.foo_1(68).read()?;
                                
                                callback(1 + 68 * 1000, "foo_1[68]", reg.into());
                            
                                
                                let reg = self.foo_1(69).read()?;
                                
                                callback(1 + 69 * 1000, "foo_1[69]", reg.into());
                            
                                
                                let reg = self.foo_1(70).read()?;
                                
                                callback(1 + 70 * 1000, "foo_1[70]", reg.into());
                            
                                
                                let reg = self.foo_1(71).read()?;
                                
                                callback(1 + 71 * 1000, "foo_1[71]", reg.into());
                            
                                
                                let reg = self.foo_1(72).read()?;
                                
                                callback(1 + 72 * 1000, "foo_1[72]", reg.into());
                            
                                
                                let reg = self.foo_1(73).read()?;
                                
                                callback(1 + 73 * 1000, "foo_1[73]", reg.into());
                            
                                
                                let reg = self.foo_1(74).read()?;
                                
                                callback(1 + 74 * 1000, "foo_1[74]", reg.into());
                            
                                
                                let reg = self.foo_1(75).read()?;
                                
                                callback(1 + 75 * 1000, "foo_1[75]", reg.into());
                            
                                
                                let reg = self.foo_1(76).read()?;
                                
                                callback(1 + 76 * 1000, "foo_1[76]", reg.into());
                            
                                
                                let reg = self.foo_1(77).read()?;
                                
                                callback(1 + 77 * 1000, "foo_1[77]", reg.into());
                            
                                
                                let reg = self.foo_1(78).read()?;
                                
                                callback(1 + 78 * 1000, "foo_1[78]", reg.into());
                            
                                
                                let reg = self.foo_1(79).read()?;
                                
                                callback(1 + 79 * 1000, "foo_1[79]", reg.into());
                            
                                
                                let reg = self.foo_1(80).read()?;
                                
                                callback(1 + 80 * 1000, "foo_1[80]", reg.into());
                            
                                
                                let reg = self.foo_1(81).read()?;
                                
                                callback(1 + 81 * 1000, "foo_1[81]", reg.into());
                            
                                
                                let reg = self.foo_1(82).read()?;
                                
                                callback(1 + 82 * 1000, "foo_1[82]", reg.into());
                            
                                
                                let reg = self.foo_1(83).read()?;
                                
                                callback(1 + 83 * 1000, "foo_1[83]", reg.into());
                            
                                
                                let reg = self.foo_1(84).read()?;
                                
                                callback(1 + 84 * 1000, "foo_1[84]", reg.into());
                            
                                
                                let reg = self.foo_1(85).read()?;
                                
                                callback(1 + 85 * 1000, "foo_1[85]", reg.into());
                            
                                
                                let reg = self.foo_1(86).read()?;
                                
                                callback(1 + 86 * 1000, "foo_1[86]", reg.into());
                            
                                
                                let reg = self.foo_1(87).read()?;
                                
                                callback(1 + 87 * 1000, "foo_1[87]", reg.into());
                            
                                
                                let reg = self.foo_1(88).read()?;
                                
                                callback(1 + 88 * 1000, "foo_1[88]", reg.into());
                            
                                
                                let reg = self.foo_1(89).read()?;
                                
                                callback(1 + 89 * 1000, "foo_1[89]", reg.into());
                            
                                
                                let reg = self.foo_1(90).read()?;
                                
                                callback(1 + 90 * 1000, "foo_1[90]", reg.into());
                            
                                
                                let reg = self.foo_1(91).read()?;
                                
                                callback(1 + 91 * 1000, "foo_1[91]", reg.into());
                            
                                
                                let reg = self.foo_1(92).read()?;
                                
                                callback(1 + 92 * 1000, "foo_1[92]", reg.into());
                            
                                
                                let reg = self.foo_1(93).read()?;
                                
                                callback(1 + 93 * 1000, "foo_1[93]", reg.into());
                            
                                
                                let reg = self.foo_1(94).read()?;
                                
                                callback(1 + 94 * 1000, "foo_1[94]", reg.into());
                            
                                
                                let reg = self.foo_1(95).read()?;
                                
                                callback(1 + 95 * 1000, "foo_1[95]", reg.into());
                            
                                
                                let reg = self.foo_1(96).read()?;
                                
                                callback(1 + 96 * 1000, "foo_1[96]", reg.into());
                            
                                
                                let reg = self.foo_1(97).read()?;
                                
                                callback(1 + 97 * 1000, "foo_1[97]", reg.into());
                            
                                
                                let reg = self.foo_1(98).read()?;
                                
                                callback(1 + 98 * 1000, "foo_1[98]", reg.into());
                            
                                
                                let reg = self.foo_1(99).read()?;
                                
                                callback(1 + 99 * 1000, "foo_1[99]", reg.into());
                            
                        
                
            
        
            
                
                    
                            
                                
                                let reg = self.foo_2(0).read()?;
                                
                                callback(2 + 0 * 1000, "foo_2[0]", reg.into());
                            
                                
                                let reg = self.foo_2(1).read()?;
                                
                                callback(2 + 1 * 1000, "foo_2[1]", reg.into());
                            
                                
                                let reg = self.foo_2(2).read()?;
                                
                                callback(2 + 2 * 1000, "foo_2[2]", reg.into());
                            
                                
                                let reg = self.foo_2(3).read()?;
                                
                                callback(2 + 3 * 1000, "foo_2[3]", reg.into());
                            
                                
                                let reg = self.foo_2(4).read()?;
                                
                                callback(2 + 4 * 1000, "foo_2[4]", reg.into());
                            
                                
                                let reg = self.foo_2(5).read()?;
                                
                                callback(2 + 5 * 1000, "foo_2[5]", reg.into());
                            
                                
                                let reg = self.foo_2(6).read()?;
                                
                                callback(2 + 6 * 1000, "foo_2[6]", reg.into());
                            
                                
                                let reg = self.foo_2(7).read()?;
                                
                                callback(2 + 7 * 1000, "foo_2[7]", reg.into());
                            
                                
                                let reg = self.foo_2(8).read()?;
                                
                                callback(2 + 8 * 1000, "foo_2[8]", reg.into());
                            
                                
                                let reg = self.foo_2(9).read()?;
                                
                                callback(2 + 9 * 1000, "foo_2[9]", reg.into());
                            
                                
                                let reg = self.foo_2(10).read()?;
                                
                                callback(2 + 10 * 1000, "foo_2[10]", reg.into());
                            
                                
                                let reg = self.foo_2(11).read()?;
                                
                                callback(2 + 11 * 1000, "foo_2[11]", reg.into());
                            
                                
                                let reg = self.foo_2(12).read()?;
                                
                                callback(2 + 12 * 1000, "foo_2[12]", reg.into());
                            
                                
                                let reg = self.foo_2(13).read()?;
                                
                                callback(2 + 13 * 1000, "foo_2[13]", reg.into());
                            
                                
                                let reg = self.foo_2(14).read()?;
                                
                                callback(2 + 14 * 1000, "foo_2[14]", reg.into());
                            
                                
                                let reg = self.foo_2(15).read()?;
                                
                                callback(2 + 15 * 1000, "foo_2[15]", reg.into());
                            
                                
                                let reg = self.foo_2(16).read()?;
                                
                                callback(2 + 16 * 1000, "foo_2[16]", reg.into());
                            
                                
                                let reg = self.foo_2(17).read()?;
                                
                                callback(2 + 17 * 1000, "foo_2[17]", reg.into());
                            
                                
                                let reg = self.foo_2(18).read()?;
                                
                                callback(2 + 18 * 1000, "foo_2[18]", reg.into());
                            
                                
                                let reg = self.foo_2(19).read()?;
                                
                                callback(2 + 19 * 1000, "foo_2[19]", reg.into());
                            
                                
                                let reg = self.foo_2(20).read()?;
                                
                                callback(2 + 20 * 1000, "foo_2[20]", reg.into());
                            
                                
                                let reg = self.foo_2(21).read()?;
                                
                                callback(2 + 21 * 1000, "foo_2[21]", reg.into());
                            
                                
                                let reg = self.foo_2(22).read()?;
                                
                                callback(2 + 22 * 1000, "foo_2[22]", reg.into());
                            
                                
                                let reg = self.foo_2(23).read()?;
                                
                                callback(2 + 23 * 1000, "foo_2[23]", reg.into());
                            
                                
                                let reg = self.foo_2(24).read()?;
                                
                                callback(2 + 24 * 1000, "foo_2[24]", reg.into());
                            
                                
                                let reg = self.foo_2(25).read()?;
                                
                                callback(2 + 25 * 1000, "foo_2[25]", reg.into());
                            
                                
                                let reg = self.foo_2(26).read()?;
                                
                                callback(2 + 26 * 1000, "foo_2[26]", reg.into());
                            
                                
                                let reg = self.foo_2(27).read()?;
                                
                                callback(2 + 27 * 1000, "foo_2[27]", reg.into());
                            
                                
                                let reg = self.foo_2(28).read()?;
                                
                                callback(2 + 28 * 1000, "foo_2[28]", reg.into());
                            
                                
                                let reg = self.foo_2(29).read()?;
                                
                                callback(2 + 29 * 1000, "foo_2[29]", reg.into());
                            
                                
                                let reg = self.foo_2(30).read()?;
                                
                                callback(2 + 30 * 1000, "foo_2[30]", reg.into());
                            
                                
                                let reg = self.foo_2(31).read()?;
                                
                                callback(2 + 31 * 1000, "foo_2[31]", reg.into());
                            
                                
                                let reg = self.foo_2(32).read()?;
                                
                                callback(2 + 32 * 1000, "foo_2[32]", reg.into());
                            
                                
                                let reg = self.foo_2(33).read()?;
                                
                                callback(2 + 33 * 1000, "foo_2[33]", reg.into());
                            
                                
                                let reg = self.foo_2(34).read()?;
                                
                                callback(2 + 34 * 1000, "foo_2[34]", reg.into());
                            
                                
                                let reg = self.foo_2(35).read()?;
                                
                                callback(2 + 35 * 1000, "foo_2[35]", reg.into());
                            
                                
                                let reg = self.foo_2(36).read()?;
                                
                                callback(2 + 36 * 1000, "foo_2[36]", reg.into());
                            
                                
                                let reg = self.foo_2(37).read()?;
                                
                                callback(2 + 37 * 1000, "foo_2[37]", reg.into());
                            
                                
                                let reg = self.foo_2(38).read()?;
                                
                                callback(2 + 38 * 1000, "foo_2[38]", reg.into());
                            
                                
                                let reg = self.foo_2(39).read()?;
                                
                                callback(2 + 39 * 1000, "foo_2[39]", reg.into());
                            
                                
                                let reg = self.foo_2(40).read()?;
                                
                                callback(2 + 40 * 1000, "foo_2[40]", reg.into());
                            
                                
                                let reg = self.foo_2(41).read()?;
                                
                                callback(2 + 41 * 1000, "foo_2[41]", reg.into());
                            
                                
                                let reg = self.foo_2(42).read()?;
                                
                                callback(2 + 42 * 1000, "foo_2[42]", reg.into());
                            
                                
                                let reg = self.foo_2(43).read()?;
                                
                                callback(2 + 43 * 1000, "foo_2[43]", reg.into());
                            
                                
                                let reg = self.foo_2(44).read()?;
                                
                                callback(2 + 44 * 1000, "foo_2[44]", reg.into());
                            
                                
                                let reg = self.foo_2(45).read()?;
                                
                                callback(2 + 45 * 1000, "foo_2[45]", reg.into());
                            
                                
                                let reg = self.foo_2(46).read()?;
                                
                                callback(2 + 46 * 1000, "foo_2[46]", reg.into());
                            
                                
                                let reg = self.foo_2(47).read()?;
                                
                                callback(2 + 47 * 1000, "foo_2[47]", reg.into());
                            
                                
                                let reg = self.foo_2(48).read()?;
                                
                                callback(2 + 48 * 1000, "foo_2[48]", reg.into());
                            
                                
                                let reg = self.foo_2(49).read()?;
                                
                                callback(2 + 49 * 1000, "foo_2[49]", reg.into());
                            
                                
                                let reg = self.foo_2(50).read()?;
                                
                                callback(2 + 50 * 1000, "foo_2[50]", reg.into());
                            
                                
                                let reg = self.foo_2(51).read()?;
                                
                                callback(2 + 51 * 1000, "foo_2[51]", reg.into());
                            
                                
                                let reg = self.foo_2(52).read()?;
                                
                                callback(2 + 52 * 1000, "foo_2[52]", reg.into());
                            
                                
                                let reg = self.foo_2(53).read()?;
                                
                                callback(2 + 53 * 1000, "foo_2[53]", reg.into());
                            
                                
                                let reg = self.foo_2(54).read()?;
                                
                                callback(2 + 54 * 1000, "foo_2[54]", reg.into());
                            
                                
                                let reg = self.foo_2(55).read()?;
                                
                                callback(2 + 55 * 1000, "foo_2[55]", reg.into());
                            
                                
                                let reg = self.foo_2(56).read()?;
                                
                                callback(2 + 56 * 1000, "foo_2[56]", reg.into());
                            
                                
                                let reg = self.foo_2(57).read()?;
                                
                                callback(2 + 57 * 1000, "foo_2[57]", reg.into());
                            
                                
                                let reg = self.foo_2(58).read()?;
                                
                                callback(2 + 58 * 1000, "foo_2[58]", reg.into());
                            
                                
                                let reg = self.foo_2(59).read()?;
                                
                                callback(2 + 59 * 1000, "foo_2[59]", reg.into());
                            
                                
                                let reg = self.foo_2(60).read()?;
                                
                                callback(2 + 60 * 1000, "foo_2[60]", reg.into());
                            
                                
                                let reg = self.foo_2(61).read()?;
                                
                                callback(2 + 61 * 1000, "foo_2[61]", reg.into());
                            
                                
                                let reg = self.foo_2(62).read()?;
                                
                                callback(2 + 62 * 1000, "foo_2[62]", reg.into());
                            
                                
                                let reg = self.foo_2(63).read()?;
                                
                                callback(2 + 63 * 1000, "foo_2[63]", reg.into());
                            
                                
                                let reg = self.foo_2(64).read()?;
                                
                                callback(2 + 64 * 1000, "foo_2[64]", reg.into());
                            
                                
                                let reg = self.foo_2(65).read()?;
                                
                                callback(2 + 65 * 1000, "foo_2[65]", reg.into());
                            
                                
                                let reg = self.foo_2(66).read()?;
                                
                                callback(2 + 66 * 1000, "foo_2[66]", reg.into());
                            
                                
                                let reg = self.foo_2(67).read()?;
                                
                                callback(2 + 67 * 1000, "foo_2[67]", reg.into());
                            
                                
                                let reg = self.foo_2(68).read()?;
                                
                                callback(2 + 68 * 1000, "foo_2[68]", reg.into());
                            
                                
                                let reg = self.foo_2(69).read()?;
                                
                                callback(2 + 69 * 1000, "foo_2[69]", reg.into());
                            
                                
                                let reg = self.foo_2(70).read()?;
                                
                                callback(2 + 70 * 1000, "foo_2[70]", reg.into());
                            
                                
                                let reg = self.foo_2(71).read()?;
                                
                                callback(2 + 71 * 1000, "foo_2[71]", reg.into());
                            
                                
                                let reg = self.foo_2(72).read()?;
                                
                                callback(2 + 72 * 1000, "foo_2[72]", reg.into());
                            
                                
                                let reg = self.foo_2(73).read()?;
                                
                                callback(2 + 73 * 1000, "foo_2[73]", reg.into());
                            
                                
                                let reg = self.foo_2(74).read()?;
                                
                                callback(2 + 74 * 1000, "foo_2[74]", reg.into());
                            
                                
                                let reg = self.foo_2(75).read()?;
                                
                                callback(2 + 75 * 1000, "foo_2[75]", reg.into());
                            
                                
                                let reg = self.foo_2(76).read()?;
                                
                                callback(2 + 76 * 1000, "foo_2[76]", reg.into());
                            
                                
                                let reg = self.foo_2(77).read()?;
                                
                                callback(2 + 77 * 1000, "foo_2[77]", reg.into());
                            
                                
                                let reg = self.foo_2(78).read()?;
                                
                                callback(2 + 78 * 1000, "foo_2[78]", reg.into());
                            
                                
                                let reg = self.foo_2(79).read()?;
                                
                                callback(2 + 79 * 1000, "foo_2[79]", reg.into());
                            
                                
                                let reg = self.foo_2(80).read()?;
                                
                                callback(2 + 80 * 1000, "foo_2[80]", reg.into());
                            
                                
                                let reg = self.foo_2(81).read()?;
                                
                                callback(2 + 81 * 1000, "foo_2[81]", reg.into());
                            
                                
                                let reg = self.foo_2(82).read()?;
                                
                                callback(2 + 82 * 1000, "foo_2[82]", reg.into());
                            
                                
                                let reg = self.foo_2(83).read()?;
                                
                                callback(2 + 83 * 1000, "foo_2[83]", reg.into());
                            
                                
                                let reg = self.foo_2(84).read()?;
                                
                                callback(2 + 84 * 1000, "foo_2[84]", reg.into());
                            
                                
                                let reg = self.foo_2(85).read()?;
                                
                                callback(2 + 85 * 1000, "foo_2[85]", reg.into());
                            
                                
                                let reg = self.foo_2(86).read()?;
                                
                                callback(2 + 86 * 1000, "foo_2[86]", reg.into());
                            
                                
                                let reg = self.foo_2(87).read()?;
                                
                                callback(2 + 87 * 1000, "foo_2[87]", reg.into());
                            
                                
                                let reg = self.foo_2(88).read()?;
                                
                                callback(2 + 88 * 1000, "foo_2[88]", reg.into());
                            
                                
                                let reg = self.foo_2(89).read()?;
                                
                                callback(2 + 89 * 1000, "foo_2[89]", reg.into());
                            
                                
                                let reg = self.foo_2(90).read()?;
                                
                                callback(2 + 90 * 1000, "foo_2[90]", reg.into());
                            
                                
                                let reg = self.foo_2(91).read()?;
                                
                                callback(2 + 91 * 1000, "foo_2[91]", reg.into());
                            
                                
                                let reg = self.foo_2(92).read()?;
                                
                                callback(2 + 92 * 1000, "foo_2[92]", reg.into());
                            
                                
                                let reg = self.foo_2(93).read()?;
                                
                                callback(2 + 93 * 1000, "foo_2[93]", reg.into());
                            
                                
                                let reg = self.foo_2(94).read()?;
                                
                                callback(2 + 94 * 1000, "foo_2[94]", reg.into());
                            
                                
                                let reg = self.foo_2(95).read()?;
                                
                                callback(2 + 95 * 1000, "foo_2[95]", reg.into());
                            
                                
                                let reg = self.foo_2(96).read()?;
                                
                                callback(2 + 96 * 1000, "foo_2[96]", reg.into());
                            
                                
                                let reg = self.foo_2(97).read()?;
                                
                                callback(2 + 97 * 1000, "foo_2[97]", reg.into());
                            
                                
                                let reg = self.foo_2(98).read()?;
                                
                                callback(2 + 98 * 1000, "foo_2[98]", reg.into());
                            
                                
                                let reg = self.foo_2(99).read()?;
                                
                                callback(2 + 99 * 1000, "foo_2[99]", reg.into());
                            
                        
                
            
        
            
                
                    
                            
                                
                                let reg = self.foo_3(0).read()?;
                                
                                callback(3 + 0 * 1000, "foo_3[0]", reg.into());
                            
                                
                                let reg = self.foo_3(1).read()?;
                                
                                callback(3 + 1 * 1000, "foo_3[1]", reg.into());
                            
                                
                                let reg = self.foo_3(2).read()?;
                                
                                callback(3 + 2 * 1000, "foo_3[2]", reg.into());
                            
                                
                                let reg = self.foo_3(3).read()?;
                                
                                callback(3 + 3 * 1000, "foo_3[3]", reg.into());
                            
                                
                                let reg = self.foo_3(4).read()?;
                                
                                callback(3 + 4 * 1000, "foo_3[4]", reg.into());
                            
                                
                                let reg = self.foo_3(5).read()?;
                                
                                callback(3 + 5 * 1000, "foo_3[5]", reg.into());
                            
                                
                                let reg = self.foo_3(6).read()?;
                                
                                callback(3 + 6 * 1000, "foo_3[6]", reg.into());
                            
                                
                                let reg = self.foo_3(7).read()?;
                                
                                callback(3 + 7 * 1000, "foo_3[7]", reg.into());
                            
                                
                                let reg = self.foo_3(8).read()?;
                                
                                callback(3 + 8 * 1000, "foo_3[8]", reg.into());
                            
                                
                                let reg = self.foo_3(9).read()?;
                                
                                callback(3 + 9 * 1000, "foo_3[9]", reg.into());
                            
                                
                                let reg = self.foo_3(10).read()?;
                                
                                callback(3 + 10 * 1000, "foo_3[10]", reg.into());
                            
                                
                                let reg = self.foo_3(11).read()?;
                                
                                callback(3 + 11 * 1000, "foo_3[11]", reg.into());
                            
                                
                                let reg = self.foo_3(12).read()?;
                                
                                callback(3 + 12 * 1000, "foo_3[12]", reg.into());
                            
                                
                                let reg = self.foo_3(13).read()?;
                                
                                callback(3 + 13 * 1000, "foo_3[13]", reg.into());
                            
                                
                                let reg = self.foo_3(14).read()?;
                                
                                callback(3 + 14 * 1000, "foo_3[14]", reg.into());
                            
                                
                                let reg = self.foo_3(15).read()?;
                                
                                callback(3 + 15 * 1000, "foo_3[15]", reg.into());
                            
                                
                                let reg = self.foo_3(16).read()?;
                                
                                callback(3 + 16 * 1000, "foo_3[16]", reg.into());
                            
                                
                                let reg = self.foo_3(17).read()?;
                                
                                callback(3 + 17 * 1000, "foo_3[17]", reg.into());
                            
                                
                                let reg = self.foo_3(18).read()?;
                                
                                callback(3 + 18 * 1000, "foo_3[18]", reg.into());
                            
                                
                                let reg = self.foo_3(19).read()?;
                                
                                callback(3 + 19 * 1000, "foo_3[19]", reg.into());
                            
                                
                                let reg = self.foo_3(20).read()?;
                                
                                callback(3 + 20 * 1000, "foo_3[20]", reg.into());
                            
                                
                                let reg = self.foo_3(21).read()?;
                                
                                callback(3 + 21 * 1000, "foo_3[21]", reg.into());
                            
                                
                                let reg = self.foo_3(22).read()?;
                                
                                callback(3 + 22 * 1000, "foo_3[22]", reg.into());
                            
                                
                                let reg = self.foo_3(23).read()?;
                                
                                callback(3 + 23 * 1000, "foo_3[23]", reg.into());
                            
                                
                                let reg = self.foo_3(24).read()?;
                                
                                callback(3 + 24 * 1000, "foo_3[24]", reg.into());
                            
                                
                                let reg = self.foo_3(25).read()?;
                                
                                callback(3 + 25 * 1000, "foo_3[25]", reg.into());
                            
                                
                                let reg = self.foo_3(26).read()?;
                                
                                callback(3 + 26 * 1000, "foo_3[26]", reg.into());
                            
                                
                                let reg = self.foo_3(27).read()?;
                                
                                callback(3 + 27 * 1000, "foo_3[27]", reg.into());
                            
                                
                                let reg = self.foo_3(28).read()?;
                                
                                callback(3 + 28 * 1000, "foo_3[28]", reg.into());
                            
                                
                                let reg = self.foo_3(29).read()?;
                                
                                callback(3 + 29 * 1000, "foo_3[29]", reg.into());
                            
                                
                                let reg = self.foo_3(30).read()?;
                                
                                callback(3 + 30 * 1000, "foo_3[30]", reg.into());
                            
                                
                                let reg = self.foo_3(31).read()?;
                                
                                callback(3 + 31 * 1000, "foo_3[31]", reg.into());
                            
                                
                                let reg = self.foo_3(32).read()?;
                                
                                callback(3 + 32 * 1000, "foo_3[32]", reg.into());
                            
                                
                                let reg = self.foo_3(33).read()?;
                                
                                callback(3 + 33 * 1000, "foo_3[33]", reg.into());
                            
                                
                                let reg = self.foo_3(34).read()?;
                                
                                callback(3 + 34 * 1000, "foo_3[34]", reg.into());
                            
                                
                                let reg = self.foo_3(35).read()?;
                                
                                callback(3 + 35 * 1000, "foo_3[35]", reg.into());
                            
                                
                                let reg = self.foo_3(36).read()?;
                                
                                callback(3 + 36 * 1000, "foo_3[36]", reg.into());
                            
                                
                                let reg = self.foo_3(37).read()?;
                                
                                callback(3 + 37 * 1000, "foo_3[37]", reg.into());
                            
                                
                                let reg = self.foo_3(38).read()?;
                                
                                callback(3 + 38 * 1000, "foo_3[38]", reg.into());
                            
                                
                                let reg = self.foo_3(39).read()?;
                                
                                callback(3 + 39 * 1000, "foo_3[39]", reg.into());
                            
                                
                                let reg = self.foo_3(40).read()?;
                                
                                callback(3 + 40 * 1000, "foo_3[40]", reg.into());
                            
                                
                                let reg = self.foo_3(41).read()?;
                                
                                callback(3 + 41 * 1000, "foo_3[41]", reg.into());
                            
                                
                                let reg = self.foo_3(42).read()?;
                                
                                callback(3 + 42 * 1000, "foo_3[42]", reg.into());
                            
                                
                                let reg = self.foo_3(43).read()?;
                                
                                callback(3 + 43 * 1000, "foo_3[43]", reg.into());
                            
                                
                                let reg = self.foo_3(44).read()?;
                                
                                callback(3 + 44 * 1000, "foo_3[44]", reg.into());
                            
                                
                                let reg = self.foo_3(45).read()?;
                                
                                callback(3 + 45 * 1000, "foo_3[45]", reg.into());
                            
                                
                                let reg = self.foo_3(46).read()?;
                                
                                callback(3 + 46 * 1000, "foo_3[46]", reg.into());
                            
                                
                                let reg = self.foo_3(47).read()?;
                                
                                callback(3 + 47 * 1000, "foo_3[47]", reg.into());
                            
                                
                                let reg = self.foo_3(48).read()?;
                                
                                callback(3 + 48 * 1000, "foo_3[48]", reg.into());
                            
                                
                                let reg = self.foo_3(49).read()?;
                                
                                callback(3 + 49 * 1000, "foo_3[49]", reg.into());
                            
                                
                                let reg = self.foo_3(50).read()?;
                                
                                callback(3 + 50 * 1000, "foo_3[50]", reg.into());
                            
                                
                                let reg = self.foo_3(51).read()?;
                                
                                callback(3 + 51 * 1000, "foo_3[51]", reg.into());
                            
                                
                                let reg = self.foo_3(52).read()?;
                                
                                callback(3 + 52 * 1000, "foo_3[52]", reg.into());
                            
                                
                                let reg = self.foo_3(53).read()?;
                                
                                callback(3 + 53 * 1000, "foo_3[53]", reg.into());
                            
                                
                                let reg = self.foo_3(54).read()?;
                                
                                callback(3 + 54 * 1000, "foo_3[54]", reg.into());
                            
                                
                                let reg = self.foo_3(55).read()?;
                                
                                callback(3 + 55 * 1000, "foo_3[55]", reg.into());
                            
                                
                                let reg = self.foo_3(56).read()?;
                                
                                callback(3 + 56 * 1000, "foo_3[56]", reg.into());
                            
                                
                                let reg = self.foo_3(57).read()?;
                                
                                callback(3 + 57 * 1000, "foo_3[57]", reg.into());
                            
                                
                                let reg = self.foo_3(58).read()?;
                                
                                callback(3 + 58 * 1000, "foo_3[58]", reg.into());
                            
                                
                                let reg = self.foo_3(59).read()?;
                                
                                callback(3 + 59 * 1000, "foo_3[59]", reg.into());
                            
                                
                                let reg = self.foo_3(60).read()?;
                                
                                callback(3 + 60 * 1000, "foo_3[60]", reg.into());
                            
                                
                                let reg = self.foo_3(61).read()?;
                                
                                callback(3 + 61 * 1000, "foo_3[61]", reg.into());
                            
                                
                                let reg = self.foo_3(62).read()?;
                                
                                callback(3 + 62 * 1000, "foo_3[62]", reg.into());
                            
                                
                                let reg = self.foo_3(63).read()?;
                                
                                callback(3 + 63 * 1000, "foo_3[63]", reg.into());
                            
                                
                                let reg = self.foo_3(64).read()?;
                                
                                callback(3 + 64 * 1000, "foo_3[64]", reg.into());
                            
                                
                                let reg = self.foo_3(65).read()?;
                                
                                callback(3 + 65 * 1000, "foo_3[65]", reg.into());
                            
                                
                                let reg = self.foo_3(66).read()?;
                                
                                callback(3 + 66 * 1000, "foo_3[66]", reg.into());
                            
                                
                                let reg = self.foo_3(67).read()?;
                                
                                callback(3 + 67 * 1000, "foo_3[67]", reg.into());
                            
                                
                                let reg = self.foo_3(68).read()?;
                                
                                callback(3 + 68 * 1000, "foo_3[68]", reg.into());
                            
                                
                                let reg = self.foo_3(69).read()?;
                                
                                callback(3 + 69 * 1000, "foo_3[69]", reg.into());
                            
                                
                                let reg = self.foo_3(70).read()?;
                                
                                callback(3 + 70 * 1000, "foo_3[70]", reg.into());
                            
                                
                                let reg = self.foo_3(71).read()?;
                                
                                callback(3 + 71 * 1000, "foo_3[71]", reg.into());
                            
                                
                                let reg = self.foo_3(72).read()?;
                                
                                callback(3 + 72 * 1000, "foo_3[72]", reg.into());
                            
                                
                                let reg = self.foo_3(73).read()?;
                                
                                callback(3 + 73 * 1000, "foo_3[73]", reg.into());
                            
                                
                                let reg = self.foo_3(74).read()?;
                                
                                callback(3 + 74 * 1000, "foo_3[74]", reg.into());
                            
                                
                                let reg = self.foo_3(75).read()?;
                                
                                callback(3 + 75 * 1000, "foo_3[75]", reg.into());
                            
                                
                                let reg = self.foo_3(76).read()?;
                                
                                callback(3 + 76 * 1000, "foo_3[76]", reg.into());
                            
                                
                                let reg = self.foo_3(77).read()?;
                                
                                callback(3 + 77 * 1000, "foo_3[77]", reg.into());
                            
                                
                                let reg = self.foo_3(78).read()?;
                                
                                callback(3 + 78 * 1000, "foo_3[78]", reg.into());
                            
                                
                                let reg = self.foo_3(79).read()?;
                                
                                callback(3 + 79 * 1000, "foo_3[79]", reg.into());
                            
                                
                                let reg = self.foo_3(80).read()?;
                                
                                callback(3 + 80 * 1000, "foo_3[80]", reg.into());
                            
                                
                                let reg = self.foo_3(81).read()?;
                                
                                callback(3 + 81 * 1000, "foo_3[81]", reg.into());
                            
                                
                                let reg = self.foo_3(82).read()?;
                                
                                callback(3 + 82 * 1000, "foo_3[82]", reg.into());
                            
                                
                                let reg = self.foo_3(83).read()?;
                                
                                callback(3 + 83 * 1000, "foo_3[83]", reg.into());
                            
                                
                                let reg = self.foo_3(84).read()?;
                                
                                callback(3 + 84 * 1000, "foo_3[84]", reg.into());
                            
                                
                                let reg = self.foo_3(85).read()?;
                                
                                callback(3 + 85 * 1000, "foo_3[85]", reg.into());
                            
                                
                                let reg = self.foo_3(86).read()?;
                                
                                callback(3 + 86 * 1000, "foo_3[86]", reg.into());
                            
                                
                                let reg = self.foo_3(87).read()?;
                                
                                callback(3 + 87 * 1000, "foo_3[87]", reg.into());
                            
                                
                                let reg = self.foo_3(88).read()?;
                                
                                callback(3 + 88 * 1000, "foo_3[88]", reg.into());
                            
                                
                                let reg = self.foo_3(89).read()?;
                                
                                callback(3 + 89 * 1000, "foo_3[89]", reg.into());
                            
                                
                                let reg = self.foo_3(90).read()?;
                                
                                callback(3 + 90 * 1000, "foo_3[90]", reg.into());
                            
                                
                                let reg = self.foo_3(91).read()?;
                                
                                callback(3 + 91 * 1000, "foo_3[91]", reg.into());
                            
                                
                                let reg = self.foo_3(92).read()?;
                                
                                callback(3 + 92 * 1000, "foo_3[92]", reg.into());
                            
                                
                                let reg = self.foo_3(93).read()?;
                                
                                callback(3 + 93 * 1000, "foo_3[93]", reg.into());
                            
                                
                                let reg = self.foo_3(94).read()?;
                                
                                callback(3 + 94 * 1000, "foo_3[94]", reg.into());
                            
                                
                                let reg = self.foo_3(95).read()?;
                                
                                callback(3 + 95 * 1000, "foo_3[95]", reg.into());
                            
                                
                                let reg = self.foo_3(96).read()?;
                                
                                callback(3 + 96 * 1000, "foo_3[96]", reg.into());
                            
                                
                                let reg = self.foo_3(97).read()?;
                                
                                callback(3 + 97 * 1000, "foo_3[97]", reg.into());
                            
                                
                                let reg = self.foo_3(98).read()?;
                                
                                callback(3 + 98 * 1000, "foo_3[98]", reg.into());
                            
                                
                                let reg = self.foo_3(99).read()?;
                                
                                callback(3 + 99 * 1000, "foo_3[99]", reg.into());
                            
                        
                
            
        
            
                
                    
                            
                                
                                let reg = self.foo_4(0).read()?;
                                
                                callback(4 + 0 * 1000, "foo_4[0]", reg.into());
                            
                                
                                let reg = self.foo_4(1).read()?;
                                
                                callback(4 + 1 * 1000, "foo_4[1]", reg.into());
                            
                                
                                let reg = self.foo_4(2).read()?;
                                
                                callback(4 + 2 * 1000, "foo_4[2]", reg.into());
                            
                                
                                let reg = self.foo_4(3).read()?;
                                
                                callback(4 + 3 * 1000, "foo_4[3]", reg.into());
                            
                                
                                let reg = self.foo_4(4).read()?;
                                
                                callback(4 + 4 * 1000, "foo_4[4]", reg.into());
                            
                                
                                let reg = self.foo_4(5).read()?;
                                
                                callback(4 + 5 * 1000, "foo_4[5]", reg.into());
                            
                                
                                let reg = self.foo_4(6).read()?;
                                
                                callback(4 + 6 * 1000, "foo_4[6]", reg.into());
                            
                                
                                let reg = self.foo_4(7).read()?;
                                
                                callback(4 + 7 * 1000, "foo_4[7]", reg.into());
                            
                                
                                let reg = self.foo_4(8).read()?;
                                
                                callback(4 + 8 * 1000, "foo_4[8]", reg.into());
                            
                                
                                let reg = self.foo_4(9).read()?;
                                
                                callback(4 + 9 * 1000, "foo_4[9]", reg.into());
                            
                                
                                let reg = self.foo_4(10).read()?;
                                
                                callback(4 + 10 * 1000, "foo_4[10]", reg.into());
                            
                                
                                let reg = self.foo_4(11).read()?;
                                
                                callback(4 + 11 * 1000, "foo_4[11]", reg.into());
                            
                                
                                let reg = self.foo_4(12).read()?;
                                
                                callback(4 + 12 * 1000, "foo_4[12]", reg.into());
                            
                                
                                let reg = self.foo_4(13).read()?;
                                
                                callback(4 + 13 * 1000, "foo_4[13]", reg.into());
                            
                                
                                let reg = self.foo_4(14).read()?;
                                
                                callback(4 + 14 * 1000, "foo_4[14]", reg.into());
                            
                                
                                let reg = self.foo_4(15).read()?;
                                
                                callback(4 + 15 * 1000, "foo_4[15]", reg.into());
                            
                                
                                let reg = self.foo_4(16).read()?;
                                
                                callback(4 + 16 * 1000, "foo_4[16]", reg.into());
                            
                                
                                let reg = self.foo_4(17).read()?;
                                
                                callback(4 + 17 * 1000, "foo_4[17]", reg.into());
                            
                                
                                let reg = self.foo_4(18).read()?;
                                
                                callback(4 + 18 * 1000, "foo_4[18]", reg.into());
                            
                                
                                let reg = self.foo_4(19).read()?;
                                
                                callback(4 + 19 * 1000, "foo_4[19]", reg.into());
                            
                                
                                let reg = self.foo_4(20).read()?;
                                
                                callback(4 + 20 * 1000, "foo_4[20]", reg.into());
                            
                                
                                let reg = self.foo_4(21).read()?;
                                
                                callback(4 + 21 * 1000, "foo_4[21]", reg.into());
                            
                                
                                let reg = self.foo_4(22).read()?;
                                
                                callback(4 + 22 * 1000, "foo_4[22]", reg.into());
                            
                                
                                let reg = self.foo_4(23).read()?;
                                
                                callback(4 + 23 * 1000, "foo_4[23]", reg.into());
                            
                                
                                let reg = self.foo_4(24).read()?;
                                
                                callback(4 + 24 * 1000, "foo_4[24]", reg.into());
                            
                                
                                let reg = self.foo_4(25).read()?;
                                
                                callback(4 + 25 * 1000, "foo_4[25]", reg.into());
                            
                                
                                let reg = self.foo_4(26).read()?;
                                
                                callback(4 + 26 * 1000, "foo_4[26]", reg.into());
                            
                                
                                let reg = self.foo_4(27).read()?;
                                
                                callback(4 + 27 * 1000, "foo_4[27]", reg.into());
                            
                                
                                let reg = self.foo_4(28).read()?;
                                
                                callback(4 + 28 * 1000, "foo_4[28]", reg.into());
                            
                                
                                let reg = self.foo_4(29).read()?;
                                
                                callback(4 + 29 * 1000, "foo_4[29]", reg.into());
                            
                                
                                let reg = self.foo_4(30).read()?;
                                
                                callback(4 + 30 * 1000, "foo_4[30]", reg.into());
                            
                                
                                let reg = self.foo_4(31).read()?;
                                
                                callback(4 + 31 * 1000, "foo_4[31]", reg.into());
                            
                                
                                let reg = self.foo_4(32).read()?;
                                
                                callback(4 + 32 * 1000, "foo_4[32]", reg.into());
                            
                                
                                let reg = self.foo_4(33).read()?;
                                
                                callback(4 + 33 * 1000, "foo_4[33]", reg.into());
                            
                                
                                let reg = self.foo_4(34).read()?;
                                
                                callback(4 + 34 * 1000, "foo_4[34]", reg.into());
                            
                                
                                let reg = self.foo_4(35).read()?;
                                
                                callback(4 + 35 * 1000, "foo_4[35]", reg.into());
                            
                                
                                let reg = self.foo_4(36).read()?;
                                
                                callback(4 + 36 * 1000, "foo_4[36]", reg.into());
                            
                                
                                let reg = self.foo_4(37).read()?;
                                
                                callback(4 + 37 * 1000, "foo_4[37]", reg.into());
                            
                                
                                let reg = self.foo_4(38).read()?;
                                
                                callback(4 + 38 * 1000, "foo_4[38]", reg.into());
                            
                                
                                let reg = self.foo_4(39).read()?;
                                
                                callback(4 + 39 * 1000, "foo_4[39]", reg.into());
                            
                                
                                let reg = self.foo_4(40).read()?;
                                
                                callback(4 + 40 * 1000, "foo_4[40]", reg.into());
                            
                                
                                let reg = self.foo_4(41).read()?;
                                
                                callback(4 + 41 * 1000, "foo_4[41]", reg.into());
                            
                                
                                let reg = self.foo_4(42).read()?;
                                
                                callback(4 + 42 * 1000, "foo_4[42]", reg.into());
                            
                                
                                let reg = self.foo_4(43).read()?;
                                
                                callback(4 + 43 * 1000, "foo_4[43]", reg.into());
                            
                                
                                let reg = self.foo_4(44).read()?;
                                
                                callback(4 + 44 * 1000, "foo_4[44]", reg.into());
                            
                                
                                let reg = self.foo_4(45).read()?;
                                
                                callback(4 + 45 * 1000, "foo_4[45]", reg.into());
                            
                                
                                let reg = self.foo_4(46).read()?;
                                
                                callback(4 + 46 * 1000, "foo_4[46]", reg.into());
                            
                                
                                let reg = self.foo_4(47).read()?;
                                
                                callback(4 + 47 * 1000, "foo_4[47]", reg.into());
                            
                                
                                let reg = self.foo_4(48).read()?;
                                
                                callback(4 + 48 * 1000, "foo_4[48]", reg.into());
                            
                                
                                let reg = self.foo_4(49).read()?;
                                
                                callback(4 + 49 * 1000, "foo_4[49]", reg.into());
                            
                                
                                let reg = self.foo_4(50).read()?;
                                
                                callback(4 + 50 * 1000, "foo_4[50]", reg.into());
                            
                                
                                let reg = self.foo_4(51).read()?;
                                
                                callback(4 + 51 * 1000, "foo_4[51]", reg.into());
                            
                                
                                let reg = self.foo_4(52).read()?;
                                
                                callback(4 + 52 * 1000, "foo_4[52]", reg.into());
                            
                                
                                let reg = self.foo_4(53).read()?;
                                
                                callback(4 + 53 * 1000, "foo_4[53]", reg.into());
                            
                                
                                let reg = self.foo_4(54).read()?;
                                
                                callback(4 + 54 * 1000, "foo_4[54]", reg.into());
                            
                                
                                let reg = self.foo_4(55).read()?;
                                
                                callback(4 + 55 * 1000, "foo_4[55]", reg.into());
                            
                                
                                let reg = self.foo_4(56).read()?;
                                
                                callback(4 + 56 * 1000, "foo_4[56]", reg.into());
                            
                                
                                let reg = self.foo_4(57).read()?;
                                
                                callback(4 + 57 * 1000, "foo_4[57]", reg.into());
                            
                                
                                let reg = self.foo_4(58).read()?;
                                
                                callback(4 + 58 * 1000, "foo_4[58]", reg.into());
                            
                                
                                let reg = self.foo_4(59).read()?;
                                
                                callback(4 + 59 * 1000, "foo_4[59]", reg.into());
                            
                                
                                let reg = self.foo_4(60).read()?;
                                
                                callback(4 + 60 * 1000, "foo_4[60]", reg.into());
                            
                                
                                let reg = self.foo_4(61).read()?;
                                
                                callback(4 + 61 * 1000, "foo_4[61]", reg.into());
                            
                                
                                let reg = self.foo_4(62).read()?;
                                
                                callback(4 + 62 * 1000, "foo_4[62]", reg.into());
                            
                                
                                let reg = self.foo_4(63).read()?;
                                
                                callback(4 + 63 * 1000, "foo_4[63]", reg.into());
                            
                                
                                let reg = self.foo_4(64).read()?;
                                
                                callback(4 + 64 * 1000, "foo_4[64]", reg.into());
                            
                                
                                let reg = self.foo_4(65).read()?;
                                
                                callback(4 + 65 * 1000, "foo_4[65]", reg.into());
                            
                                
                                let reg = self.foo_4(66).read()?;
                                
                                callback(4 + 66 * 1000, "foo_4[66]", reg.into());
                            
                                
                                let reg = self.foo_4(67).read()?;
                                
                                callback(4 + 67 * 1000, "foo_4[67]", reg.into());
                            
                                
                                let reg = self.foo_4(68).read()?;
                                
                                callback(4 + 68 * 1000, "foo_4[68]", reg.into());
                            
                                
                                let reg = self.foo_4(69).read()?;
                                
                                callback(4 + 69 * 1000, "foo_4[69]", reg.into());
                            
                                
                                let reg = self.foo_4(70).read()?;
                                
                                callback(4 + 70 * 1000, "foo_4[70]", reg.into());
                            
                                
                                let reg = self.foo_4(71).read()?;
                                
                                callback(4 + 71 * 1000, "foo_4[71]", reg.into());
                            
                                
                                let reg = self.foo_4(72).read()?;
                                
                                callback(4 + 72 * 1000, "foo_4[72]", reg.into());
                            
                                
                                let reg = self.foo_4(73).read()?;
                                
                                callback(4 + 73 * 1000, "foo_4[73]", reg.into());
                            
                                
                                let reg = self.foo_4(74).read()?;
                                
                                callback(4 + 74 * 1000, "foo_4[74]", reg.into());
                            
                                
                                let reg = self.foo_4(75).read()?;
                                
                                callback(4 + 75 * 1000, "foo_4[75]", reg.into());
                            
                                
                                let reg = self.foo_4(76).read()?;
                                
                                callback(4 + 76 * 1000, "foo_4[76]", reg.into());
                            
                                
                                let reg = self.foo_4(77).read()?;
                                
                                callback(4 + 77 * 1000, "foo_4[77]", reg.into());
                            
                                
                                let reg = self.foo_4(78).read()?;
                                
                                callback(4 + 78 * 1000, "foo_4[78]", reg.into());
                            
                                
                                let reg = self.foo_4(79).read()?;
                                
                                callback(4 + 79 * 1000, "foo_4[79]", reg.into());
                            
                                
                                let reg = self.foo_4(80).read()?;
                                
                                callback(4 + 80 * 1000, "foo_4[80]", reg.into());
                            
                                
                                let reg = self.foo_4(81).read()?;
                                
                                callback(4 + 81 * 1000, "foo_4[81]", reg.into());
                            
                                
                                let reg = self.foo_4(82).read()?;
                                
                                callback(4 + 82 * 1000, "foo_4[82]", reg.into());
                            
                                
                                let reg = self.foo_4(83).read()?;
                                
                                callback(4 + 83 * 1000, "foo_4[83]", reg.into());
                            
                                
                                let reg = self.foo_4(84).read()?;
                                
                                callback(4 + 84 * 1000, "foo_4[84]", reg.into());
                            
                                
                                let reg = self.foo_4(85).read()?;
                                
                                callback(4 + 85 * 1000, "foo_4[85]", reg.into());
                            
                                
                                let reg = self.foo_4(86).read()?;
                                
                                callback(4 + 86 * 1000, "foo_4[86]", reg.into());
                            
                                
                                let reg = self.foo_4(87).read()?;
                                
                                callback(4 + 87 * 1000, "foo_4[87]", reg.into());
                            
                                
                                let reg = self.foo_4(88).read()?;
                                
                                callback(4 + 88 * 1000, "foo_4[88]", reg.into());
                            
                                
                                let reg = self.foo_4(89).read()?;
                                
                                callback(4 + 89 * 1000, "foo_4[89]", reg.into());
                            
                                
                                let reg = self.foo_4(90).read()?;
                                
                                callback(4 + 90 * 1000, "foo_4[90]", reg.into());
                            
                                
                                let reg = self.foo_4(91).read()?;
                                
                                callback(4 + 91 * 1000, "foo_4[91]", reg.into());
                            
                                
                                let reg = self.foo_4(92).read()?;
                                
                                callback(4 + 92 * 1000, "foo_4[92]", reg.into());
                            
                                
                                let reg = self.foo_4(93).read()?;
                                
                                callback(4 + 93 * 1000, "foo_4[93]", reg.into());
                            
                                
                                let reg = self.foo_4(94).read()?;
                                
                                callback(4 + 94 * 1000, "foo_4[94]", reg.into());
                            
                                
                                let reg = self.foo_4(95).read()?;
                                
                                callback(4 + 95 * 1000, "foo_4[95]", reg.into());
                            
                                
                                let reg = self.foo_4(96).read()?;
                                
                                callback(4 + 96 * 1000, "foo_4[96]", reg.into());
                            
                                
                                let reg = self.foo_4(97).read()?;
                                
                                callback(4 + 97 * 1000, "foo_4[97]", reg.into());
                            
                                
                                let reg = self.foo_4(98).read()?;
                                
                                callback(4 + 98 * 1000, "foo_4[98]", reg.into());
                            
                                
                                let reg = self.foo_4(99).read()?;
                                
                                callback(4 + 99 * 1000, "foo_4[99]", reg.into());
                            
                        
                
            
        
            
                
                    
                            
                                
                                let reg = self.foo_5(0).read()?;
                                
                                callback(5 + 0 * 1000, "foo_5[0]", reg.into());
                            
                                
                                let reg = self.foo_5(1).read()?;
                                
                                callback(5 + 1 * 1000, "foo_5[1]", reg.into());
                            
                                
                                let reg = self.foo_5(2).read()?;
                                
                                callback(5 + 2 * 1000, "foo_5[2]", reg.into());
                            
                                
                                let reg = self.foo_5(3).read()?;
                                
                                callback(5 + 3 * 1000, "foo_5[3]", reg.into());
                            
                                
                                let reg = self.foo_5(4).read()?;
                                
                                callback(5 + 4 * 1000, "foo_5[4]", reg.into());
                            
                                
                                let reg = self.foo_5(5).read()?;
                                
                                callback(5 + 5 * 1000, "foo_5[5]", reg.into());
                            
                                
                                let reg = self.foo_5(6).read()?;
                                
                                callback(5 + 6 * 1000, "foo_5[6]", reg.into());
                            
                                
                                let reg = self.foo_5(7).read()?;
                                
                                callback(5 + 7 * 1000, "foo_5[7]", reg.into());
                            
                                
                                let reg = self.foo_5(8).read()?;
                                
                                callback(5 + 8 * 1000, "foo_5[8]", reg.into());
                            
                                
                                let reg = self.foo_5(9).read()?;
                                
                                callback(5 + 9 * 1000, "foo_5[9]", reg.into());
                            
                                
                                let reg = self.foo_5(10).read()?;
                                
                                callback(5 + 10 * 1000, "foo_5[10]", reg.into());
                            
                                
                                let reg = self.foo_5(11).read()?;
                                
                                callback(5 + 11 * 1000, "foo_5[11]", reg.into());
                            
                                
                                let reg = self.foo_5(12).read()?;
                                
                                callback(5 + 12 * 1000, "foo_5[12]", reg.into());
                            
                                
                                let reg = self.foo_5(13).read()?;
                                
                                callback(5 + 13 * 1000, "foo_5[13]", reg.into());
                            
                                
                                let reg = self.foo_5(14).read()?;
                                
                                callback(5 + 14 * 1000, "foo_5[14]", reg.into());
                            
                                
                                let reg = self.foo_5(15).read()?;
                                
                                callback(5 + 15 * 1000, "foo_5[15]", reg.into());
                            
                                
                                let reg = self.foo_5(16).read()?;
                                
                                callback(5 + 16 * 1000, "foo_5[16]", reg.into());
                            
                                
                                let reg = self.foo_5(17).read()?;
                                
                                callback(5 + 17 * 1000, "foo_5[17]", reg.into());
                            
                                
                                let reg = self.foo_5(18).read()?;
                                
                                callback(5 + 18 * 1000, "foo_5[18]", reg.into());
                            
                                
                                let reg = self.foo_5(19).read()?;
                                
                                callback(5 + 19 * 1000, "foo_5[19]", reg.into());
                            
                                
                                let reg = self.foo_5(20).read()?;
                                
                                callback(5 + 20 * 1000, "foo_5[20]", reg.into());
                            
                                
                                let reg = self.foo_5(21).read()?;
                                
                                callback(5 + 21 * 1000, "foo_5[21]", reg.into());
                            
                                
                                let reg = self.foo_5(22).read()?;
                                
                                callback(5 + 22 * 1000, "foo_5[22]", reg.into());
                            
                                
                                let reg = self.foo_5(23).read()?;
                                
                                callback(5 + 23 * 1000, "foo_5[23]", reg.into());
                            
                                
                                let reg = self.foo_5(24).read()?;
                                
                                callback(5 + 24 * 1000, "foo_5[24]", reg.into());
                            
                                
                                let reg = self.foo_5(25).read()?;
                                
                                callback(5 + 25 * 1000, "foo_5[25]", reg.into());
                            
                                
                                let reg = self.foo_5(26).read()?;
                                
                                callback(5 + 26 * 1000, "foo_5[26]", reg.into());
                            
                                
                                let reg = self.foo_5(27).read()?;
                                
                                callback(5 + 27 * 1000, "foo_5[27]", reg.into());
                            
                                
                                let reg = self.foo_5(28).read()?;
                                
                                callback(5 + 28 * 1000, "foo_5[28]", reg.into());
                            
                                
                                let reg = self.foo_5(29).read()?;
                                
                                callback(5 + 29 * 1000, "foo_5[29]", reg.into());
                            
                                
                                let reg = self.foo_5(30).read()?;
                                
                                callback(5 + 30 * 1000, "foo_5[30]", reg.into());
                            
                                
                                let reg = self.foo_5(31).read()?;
                                
                                callback(5 + 31 * 1000, "foo_5[31]", reg.into());
                            
                                
                                let reg = self.foo_5(32).read()?;
                                
                                callback(5 + 32 * 1000, "foo_5[32]", reg.into());
                            
                                
                                let reg = self.foo_5(33).read()?;
                                
                                callback(5 + 33 * 1000, "foo_5[33]", reg.into());
                            
                                
                                let reg = self.foo_5(34).read()?;
                                
                                callback(5 + 34 * 1000, "foo_5[34]", reg.into());
                            
                                
                                let reg = self.foo_5(35).read()?;
                                
                                callback(5 + 35 * 1000, "foo_5[35]", reg.into());
                            
                                
                                let reg = self.foo_5(36).read()?;
                                
                                callback(5 + 36 * 1000, "foo_5[36]", reg.into());
                            
                                
                                let reg = self.foo_5(37).read()?;
                                
                                callback(5 + 37 * 1000, "foo_5[37]", reg.into());
                            
                                
                                let reg = self.foo_5(38).read()?;
                                
                                callback(5 + 38 * 1000, "foo_5[38]", reg.into());
                            
                                
                                let reg = self.foo_5(39).read()?;
                                
                                callback(5 + 39 * 1000, "foo_5[39]", reg.into());
                            
                                
                                let reg = self.foo_5(40).read()?;
                                
                                callback(5 + 40 * 1000, "foo_5[40]", reg.into());
                            
                                
                                let reg = self.foo_5(41).read()?;
                                
                                callback(5 + 41 * 1000, "foo_5[41]", reg.into());
                            
                                
                                let reg = self.foo_5(42).read()?;
                                
                                callback(5 + 42 * 1000, "foo_5[42]", reg.into());
                            
                                
                                let reg = self.foo_5(43).read()?;
                                
                                callback(5 + 43 * 1000, "foo_5[43]", reg.into());
                            
                                
                                let reg = self.foo_5(44).read()?;
                                
                                callback(5 + 44 * 1000, "foo_5[44]", reg.into());
                            
                                
                                let reg = self.foo_5(45).read()?;
                                
                                callback(5 + 45 * 1000, "foo_5[45]", reg.into());
                            
                                
                                let reg = self.foo_5(46).read()?;
                                
                                callback(5 + 46 * 1000, "foo_5[46]", reg.into());
                            
                                
                                let reg = self.foo_5(47).read()?;
                                
                                callback(5 + 47 * 1000, "foo_5[47]", reg.into());
                            
                                
                                let reg = self.foo_5(48).read()?;
                                
                                callback(5 + 48 * 1000, "foo_5[48]", reg.into());
                            
                                
                                let reg = self.foo_5(49).read()?;
                                
                                callback(5 + 49 * 1000, "foo_5[49]", reg.into());
                            
                                
                                let reg = self.foo_5(50).read()?;
                                
                                callback(5 + 50 * 1000, "foo_5[50]", reg.into());
                            
                                
                                let reg = self.foo_5(51).read()?;
                                
                                callback(5 + 51 * 1000, "foo_5[51]", reg.into());
                            
                                
                                let reg = self.foo_5(52).read()?;
                                
                                callback(5 + 52 * 1000, "foo_5[52]", reg.into());
                            
                                
                                let reg = self.foo_5(53).read()?;
                                
                                callback(5 + 53 * 1000, "foo_5[53]", reg.into());
                            
                                
                                let reg = self.foo_5(54).read()?;
                                
                                callback(5 + 54 * 1000, "foo_5[54]", reg.into());
                            
                                
                                let reg = self.foo_5(55).read()?;
                                
                                callback(5 + 55 * 1000, "foo_5[55]", reg.into());
                            
                                
                                let reg = self.foo_5(56).read()?;
                                
                                callback(5 + 56 * 1000, "foo_5[56]", reg.into());
                            
                                
                                let reg = self.foo_5(57).read()?;
                                
                                callback(5 + 57 * 1000, "foo_5[57]", reg.into());
                            
                                
                                let reg = self.foo_5(58).read()?;
                                
                                callback(5 + 58 * 1000, "foo_5[58]", reg.into());
                            
                                
                                let reg = self.foo_5(59).read()?;
                                
                                callback(5 + 59 * 1000, "foo_5[59]", reg.into());
                            
                                
                                let reg = self.foo_5(60).read()?;
                                
                                callback(5 + 60 * 1000, "foo_5[60]", reg.into());
                            
                                
                                let reg = self.foo_5(61).read()?;
                                
                                callback(5 + 61 * 1000, "foo_5[61]", reg.into());
                            
                                
                                let reg = self.foo_5(62).read()?;
                                
                                callback(5 + 62 * 1000, "foo_5[62]", reg.into());
                            
                                
                                let reg = self.foo_5(63).read()?;
                                
                                callback(5 + 63 * 1000, "foo_5[63]", reg.into());
                            
                                
                                let reg = self.foo_5(64).read()?;
                                
                                callback(5 + 64 * 1000, "foo_5[64]", reg.into());
                            
                                
                                let reg = self.foo_5(65).read()?;
                                
                                callback(5 + 65 * 1000, "foo_5[65]", reg.into());
                            
                                
                                let reg = self.foo_5(66).read()?;
                                
                                callback(5 + 66 * 1000, "foo_5[66]", reg.into());
                            
                                
                                let reg = self.foo_5(67).read()?;
                                
                                callback(5 + 67 * 1000, "foo_5[67]", reg.into());
                            
                                
                                let reg = self.foo_5(68).read()?;
                                
                                callback(5 + 68 * 1000, "foo_5[68]", reg.into());
                            
                                
                                let reg = self.foo_5(69).read()?;
                                
                                callback(5 + 69 * 1000, "foo_5[69]", reg.into());
                            
                                
                                let reg = self.foo_5(70).read()?;
                                
                                callback(5 + 70 * 1000, "foo_5[70]", reg.into());
                            
                                
                                let reg = self.foo_5(71).read()?;
                                
                                callback(5 + 71 * 1000, "foo_5[71]", reg.into());
                            
                                
                                let reg = self.foo_5(72).read()?;
                                
                                callback(5 + 72 * 1000, "foo_5[72]", reg.into());
                            
                                
                                let reg = self.foo_5(73).read()?;
                                
                                callback(5 + 73 * 1000, "foo_5[73]", reg.into());
                            
                                
                                let reg = self.foo_5(74).read()?;
                                
                                callback(5 + 74 * 1000, "foo_5[74]", reg.into());
                            
                                
                                let reg = self.foo_5(75).read()?;
                                
                                callback(5 + 75 * 1000, "foo_5[75]", reg.into());
                            
                                
                                let reg = self.foo_5(76).read()?;
                                
                                callback(5 + 76 * 1000, "foo_5[76]", reg.into());
                            
                                
                                let reg = self.foo_5(77).read()?;
                                
                                callback(5 + 77 * 1000, "foo_5[77]", reg.into());
                            
                                
                                let reg = self.foo_5(78).read()?;
                                
                                callback(5 + 78 * 1000, "foo_5[78]", reg.into());
                            
                                
                                let reg = self.foo_5(79).read()?;
                                
                                callback(5 + 79 * 1000, "foo_5[79]", reg.into());
                            
                                
                                let reg = self.foo_5(80).read()?;
                                
                                callback(5 + 80 * 1000, "foo_5[80]", reg.into());
                            
                                
                                let reg = self.foo_5(81).read()?;
                                
                                callback(5 + 81 * 1000, "foo_5[81]", reg.into());
                            
                                
                                let reg = self.foo_5(82).read()?;
                                
                                callback(5 + 82 * 1000, "foo_5[82]", reg.into());
                            
                                
                                let reg = self.foo_5(83).read()?;
                                
                                callback(5 + 83 * 1000, "foo_5[83]", reg.into());
                            
                                
                                let reg = self.foo_5(84).read()?;
                                
                                callback(5 + 84 * 1000, "foo_5[84]", reg.into());
                            
                                
                                let reg = self.foo_5(85).read()?;
                                
                                callback(5 + 85 * 1000, "foo_5[85]", reg.into());
                            
                                
                                let reg = self.foo_5(86).read()?;
                                
                                callback(5 + 86 * 1000, "foo_5[86]", reg.into());
                            
                                
                                let reg = self.foo_5(87).read()?;
                                
                                callback(5 + 87 * 1000, "foo_5[87]", reg.into());
                            
                                
                                let reg = self.foo_5(88).read()?;
                                
                                callback(5 + 88 * 1000, "foo_5[88]", reg.into());
                            
                                
                                let reg = self.foo_5(89).read()?;
                                
                                callback(5 + 89 * 1000, "foo_5[89]", reg.into());
                            
                                
                                let reg = self.foo_5(90).read()?;
                                
                                callback(5 + 90 * 1000, "foo_5[90]", reg.into());
                            
                                
                                let reg = self.foo_5(91).read()?;
                                
                                callback(5 + 91 * 1000, "foo_5[91]", reg.into());
                            
                                
                                let reg = self.foo_5(92).read()?;
                                
                                callback(5 + 92 * 1000, "foo_5[92]", reg.into());
                            
                                
                                let reg = self.foo_5(93).read()?;
                                
                                callback(5 + 93 * 1000, "foo_5[93]", reg.into());
                            
                                
                                let reg = self.foo_5(94).read()?;
                                
                                callback(5 + 94 * 1000, "foo_5[94]", reg.into());
                            
                                
                                let reg = self.foo_5(95).read()?;
                                
                                callback(5 + 95 * 1000, "foo_5[95]", reg.into());
                            
                                
                                let reg = self.foo_5(96).read()?;
                                
                                callback(5 + 96 * 1000, "foo_5[96]", reg.into());
                            
                                
                                let reg = self.foo_5(97).read()?;
                                
                                callback(5 + 97 * 1000, "foo_5[97]", reg.into());
                            
                                
                                let reg = self.foo_5(98).read()?;
                                
                                callback(5 + 98 * 1000, "foo_5[98]", reg.into());
                            
                                
                                let reg = self.foo_5(99).read()?;
                                
                                callback(5 + 99 * 1000, "foo_5[99]", reg.into());
                            
                        
                
            
        
            
                
                    
                            
                                
                                let reg = self.foo_6(0).read()?;
                                
                                callback(6 + 0 * 1000, "foo_6[0]", reg.into());
                            
                                
                                let reg = self.foo_6(1).read()?;
                                
                                callback(6 + 1 * 1000, "foo_6[1]", reg.into());
                            
                                
                                let reg = self.foo_6(2).read()?;
                                
                                callback(6 + 2 * 1000, "foo_6[2]", reg.into());
                            
                                
                                let reg = self.foo_6(3).read()?;
                                
                                callback(6 + 3 * 1000, "foo_6[3]", reg.into());
                            
                                
                                let reg = self.foo_6(4).read()?;
                                
                                callback(6 + 4 * 1000, "foo_6[4]", reg.into());
                            
                                
                                let reg = self.foo_6(5).read()?;
                                
                                callback(6 + 5 * 1000, "foo_6[5]", reg.into());
                            
                                
                                let reg = self.foo_6(6).read()?;
                                
                                callback(6 + 6 * 1000, "foo_6[6]", reg.into());
                            
                                
                                let reg = self.foo_6(7).read()?;
                                
                                callback(6 + 7 * 1000, "foo_6[7]", reg.into());
                            
                                
                                let reg = self.foo_6(8).read()?;
                                
                                callback(6 + 8 * 1000, "foo_6[8]", reg.into());
                            
                                
                                let reg = self.foo_6(9).read()?;
                                
                                callback(6 + 9 * 1000, "foo_6[9]", reg.into());
                            
                                
                                let reg = self.foo_6(10).read()?;
                                
                                callback(6 + 10 * 1000, "foo_6[10]", reg.into());
                            
                                
                                let reg = self.foo_6(11).read()?;
                                
                                callback(6 + 11 * 1000, "foo_6[11]", reg.into());
                            
                                
                                let reg = self.foo_6(12).read()?;
                                
                                callback(6 + 12 * 1000, "foo_6[12]", reg.into());
                            
                                
                                let reg = self.foo_6(13).read()?;
                                
                                callback(6 + 13 * 1000, "foo_6[13]", reg.into());
                            
                                
                                let reg = self.foo_6(14).read()?;
                                
                                callback(6 + 14 * 1000, "foo_6[14]", reg.into());
                            
                                
                                let reg = self.foo_6(15).read()?;
                                
                                callback(6 + 15 * 1000, "foo_6[15]", reg.into());
                            
                                
                                let reg = self.foo_6(16).read()?;
                                
                                callback(6 + 16 * 1000, "foo_6[16]", reg.into());
                            
                                
                                let reg = self.foo_6(17).read()?;
                                
                                callback(6 + 17 * 1000, "foo_6[17]", reg.into());
                            
                                
                                let reg = self.foo_6(18).read()?;
                                
                                callback(6 + 18 * 1000, "foo_6[18]", reg.into());
                            
                                
                                let reg = self.foo_6(19).read()?;
                                
                                callback(6 + 19 * 1000, "foo_6[19]", reg.into());
                            
                                
                                let reg = self.foo_6(20).read()?;
                                
                                callback(6 + 20 * 1000, "foo_6[20]", reg.into());
                            
                                
                                let reg = self.foo_6(21).read()?;
                                
                                callback(6 + 21 * 1000, "foo_6[21]", reg.into());
                            
                                
                                let reg = self.foo_6(22).read()?;
                                
                                callback(6 + 22 * 1000, "foo_6[22]", reg.into());
                            
                                
                                let reg = self.foo_6(23).read()?;
                                
                                callback(6 + 23 * 1000, "foo_6[23]", reg.into());
                            
                                
                                let reg = self.foo_6(24).read()?;
                                
                                callback(6 + 24 * 1000, "foo_6[24]", reg.into());
                            
                                
                                let reg = self.foo_6(25).read()?;
                                
                                callback(6 + 25 * 1000, "foo_6[25]", reg.into());
                            
                                
                                let reg = self.foo_6(26).read()?;
                                
                                callback(6 + 26 * 1000, "foo_6[26]", reg.into());
                            
                                
                                let reg = self.foo_6(27).read()?;
                                
                                callback(6 + 27 * 1000, "foo_6[27]", reg.into());
                            
                                
                                let reg = self.foo_6(28).read()?;
                                
                                callback(6 + 28 * 1000, "foo_6[28]", reg.into());
                            
                                
                                let reg = self.foo_6(29).read()?;
                                
                                callback(6 + 29 * 1000, "foo_6[29]", reg.into());
                            
                                
                                let reg = self.foo_6(30).read()?;
                                
                                callback(6 + 30 * 1000, "foo_6[30]", reg.into());
                            
                                
                                let reg = self.foo_6(31).read()?;
                                
                                callback(6 + 31 * 1000, "foo_6[31]", reg.into());
                            
                                
                                let reg = self.foo_6(32).read()?;
                                
                                callback(6 + 32 * 1000, "foo_6[32]", reg.into());
                            
                                
                                let reg = self.foo_6(33).read()?;
                                
                                callback(6 + 33 * 1000, "foo_6[33]", reg.into());
                            
                                
                                let reg = self.foo_6(34).read()?;
                                
                                callback(6 + 34 * 1000, "foo_6[34]", reg.into());
                            
                                
                                let reg = self.foo_6(35).read()?;
                                
                                callback(6 + 35 * 1000, "foo_6[35]", reg.into());
                            
                                
                                let reg = self.foo_6(36).read()?;
                                
                                callback(6 + 36 * 1000, "foo_6[36]", reg.into());
                            
                                
                                let reg = self.foo_6(37).read()?;
                                
                                callback(6 + 37 * 1000, "foo_6[37]", reg.into());
                            
                                
                                let reg = self.foo_6(38).read()?;
                                
                                callback(6 + 38 * 1000, "foo_6[38]", reg.into());
                            
                                
                                let reg = self.foo_6(39).read()?;
                                
                                callback(6 + 39 * 1000, "foo_6[39]", reg.into());
                            
                                
                                let reg = self.foo_6(40).read()?;
                                
                                callback(6 + 40 * 1000, "foo_6[40]", reg.into());
                            
                                
                                let reg = self.foo_6(41).read()?;
                                
                                callback(6 + 41 * 1000, "foo_6[41]", reg.into());
                            
                                
                                let reg = self.foo_6(42).read()?;
                                
                                callback(6 + 42 * 1000, "foo_6[42]", reg.into());
                            
                                
                                let reg = self.foo_6(43).read()?;
                                
                                callback(6 + 43 * 1000, "foo_6[43]", reg.into());
                            
                                
                                let reg = self.foo_6(44).read()?;
                                
                                callback(6 + 44 * 1000, "foo_6[44]", reg.into());
                            
                                
                                let reg = self.foo_6(45).read()?;
                                
                                callback(6 + 45 * 1000, "foo_6[45]", reg.into());
                            
                                
                                let reg = self.foo_6(46).read()?;
                                
                                callback(6 + 46 * 1000, "foo_6[46]", reg.into());
                            
                                
                                let reg = self.foo_6(47).read()?;
                                
                                callback(6 + 47 * 1000, "foo_6[47]", reg.into());
                            
                                
                                let reg = self.foo_6(48).read()?;
                                
                                callback(6 + 48 * 1000, "foo_6[48]", reg.into());
                            
                                
                                let reg = self.foo_6(49).read()?;
                                
                                callback(6 + 49 * 1000, "foo_6[49]", reg.into());
                            
                                
                                let reg = self.foo_6(50).read()?;
                                
                                callback(6 + 50 * 1000, "foo_6[50]", reg.into());
                            
                                
                                let reg = self.foo_6(51).read()?;
                                
                                callback(6 + 51 * 1000, "foo_6[51]", reg.into());
                            
                                
                                let reg = self.foo_6(52).read()?;
                                
                                callback(6 + 52 * 1000, "foo_6[52]", reg.into());
                            
                                
                                let reg = self.foo_6(53).read()?;
                                
                                callback(6 + 53 * 1000, "foo_6[53]", reg.into());
                            
                                
                                let reg = self.foo_6(54).read()?;
                                
                                callback(6 + 54 * 1000, "foo_6[54]", reg.into());
                            
                                
                                let reg = self.foo_6(55).read()?;
                                
                                callback(6 + 55 * 1000, "foo_6[55]", reg.into());
                            
                                
                                let reg = self.foo_6(56).read()?;
                                
                                callback(6 + 56 * 1000, "foo_6[56]", reg.into());
                            
                                
                                let reg = self.foo_6(57).read()?;
                                
                                callback(6 + 57 * 1000, "foo_6[57]", reg.into());
                            
                                
                                let reg = self.foo_6(58).read()?;
                                
                                callback(6 + 58 * 1000, "foo_6[58]", reg.into());
                            
                                
                                let reg = self.foo_6(59).read()?;
                                
                                callback(6 + 59 * 1000, "foo_6[59]", reg.into());
                            
                                
                                let reg = self.foo_6(60).read()?;
                                
                                callback(6 + 60 * 1000, "foo_6[60]", reg.into());
                            
                                
                                let reg = self.foo_6(61).read()?;
                                
                                callback(6 + 61 * 1000, "foo_6[61]", reg.into());
                            
                                
                                let reg = self.foo_6(62).read()?;
                                
                                callback(6 + 62 * 1000, "foo_6[62]", reg.into());
                            
                                
                                let reg = self.foo_6(63).read()?;
                                
                                callback(6 + 63 * 1000, "foo_6[63]", reg.into());
                            
                                
                                let reg = self.foo_6(64).read()?;
                                
                                callback(6 + 64 * 1000, "foo_6[64]", reg.into());
                            
                                
                                let reg = self.foo_6(65).read()?;
                                
                                callback(6 + 65 * 1000, "foo_6[65]", reg.into());
                            
                                
                                let reg = self.foo_6(66).read()?;
                                
                                callback(6 + 66 * 1000, "foo_6[66]", reg.into());
                            
                                
                                let reg = self.foo_6(67).read()?;
                                
                                callback(6 + 67 * 1000, "foo_6[67]", reg.into());
                            
                                
                                let reg = self.foo_6(68).read()?;
                                
                                callback(6 + 68 * 1000, "foo_6[68]", reg.into());
                            
                                
                                let reg = self.foo_6(69).read()?;
                                
                                callback(6 + 69 * 1000, "foo_6[69]", reg.into());
                            
                                
                                let reg = self.foo_6(70).read()?;
                                
                                callback(6 + 70 * 1000, "foo_6[70]", reg.into());
                            
                                
                                let reg = self.foo_6(71).read()?;
                                
                                callback(6 + 71 * 1000, "foo_6[71]", reg.into());
                            
                                
                                let reg = self.foo_6(72).read()?;
                                
                                callback(6 + 72 * 1000, "foo_6[72]", reg.into());
                            
                                
                                let reg = self.foo_6(73).read()?;
                                
                                callback(6 + 73 * 1000, "foo_6[73]", reg.into());
                            
                                
                                let reg = self.foo_6(74).read()?;
                                
                                callback(6 + 74 * 1000, "foo_6[74]", reg.into());
                            
                                
                                let reg = self.foo_6(75).read()?;
                                
                                callback(6 + 75 * 1000, "foo_6[75]", reg.into());
                            
                                
                                let reg = self.foo_6(76).read()?;
                                
                                callback(6 + 76 * 1000, "foo_6[76]", reg.into());
                            
                                
                                let reg = self.foo_6(77).read()?;
                                
                                callback(6 + 77 * 1000, "foo_6[77]", reg.into());
                            
                                
                                let reg = self.foo_6(78).read()?;
                                
                                callback(6 + 78 * 1000, "foo_6[78]", reg.into());
                            
                                
                                let reg = self.foo_6(79).read()?;
                                
                                callback(6 + 79 * 1000, "foo_6[79]", reg.into());
                            
                                
                                let reg = self.foo_6(80).read()?;
                                
                                callback(6 + 80 * 1000, "foo_6[80]", reg.into());
                            
                                
                                let reg = self.foo_6(81).read()?;
                                
                                callback(6 + 81 * 1000, "foo_6[81]", reg.into());
                            
                                
                                let reg = self.foo_6(82).read()?;
                                
                                callback(6 + 82 * 1000, "foo_6[82]", reg.into());
                            
                                
                                let reg = self.foo_6(83).read()?;
                                
                                callback(6 + 83 * 1000, "foo_6[83]", reg.into());
                            
                                
                                let reg = self.foo_6(84).read()?;
                                
                                callback(6 + 84 * 1000, "foo_6[84]", reg.into());
                            
                                
                                let reg = self.foo_6(85).read()?;
                                
                                callback(6 + 85 * 1000, "foo_6[85]", reg.into());
                            
                                
                                let reg = self.foo_6(86).read()?;
                                
                                callback(6 + 86 * 1000, "foo_6[86]", reg.into());
                            
                                
                                let reg = self.foo_6(87).read()?;
                                
                                callback(6 + 87 * 1000, "foo_6[87]", reg.into());
                            
                                
                                let reg = self.foo_6(88).read()?;
                                
                                callback(6 + 88 * 1000, "foo_6[88]", reg.into());
                            
                                
                                let reg = self.foo_6(89).read()?;
                                
                                callback(6 + 89 * 1000, "foo_6[89]", reg.into());
                            
                                
                                let reg = self.foo_6(90).read()?;
                                
                                callback(6 + 90 * 1000, "foo_6[90]", reg.into());
                            
                                
                                let reg = self.foo_6(91).read()?;
                                
                                callback(6 + 91 * 1000, "foo_6[91]", reg.into());
                            
                                
                                let reg = self.foo_6(92).read()?;
                                
                                callback(6 + 92 * 1000, "foo_6[92]", reg.into());
                            
                                
                                let reg = self.foo_6(93).read()?;
                                
                                callback(6 + 93 * 1000, "foo_6[93]", reg.into());
                            
                                
                                let reg = self.foo_6(94).read()?;
                                
                                callback(6 + 94 * 1000, "foo_6[94]", reg.into());
                            
                                
                                let reg = self.foo_6(95).read()?;
                                
                                callback(6 + 95 * 1000, "foo_6[95]", reg.into());
                            
                                
                                let reg = self.foo_6(96).read()?;
                                
                                callback(6 + 96 * 1000, "foo_6[96]", reg.into());
                            
                                
                                let reg = self.foo_6(97).read()?;
                                
                                callback(6 + 97 * 1000, "foo_6[97]", reg.into());
                            
                                
                                let reg = self.foo_6(98).read()?;
                                
                                callback(6 + 98 * 1000, "foo_6[98]", reg.into());
                            
                                
                                let reg = self.foo_6(99).read()?;
                                
                                callback(6 + 99 * 1000, "foo_6[99]", reg.into());
                            
                        
                
            
        
            
                
                    
                            
                                
                                let reg = self.foo_7(0).read()?;
                                
                                callback(7 + 0 * 1000, "foo_7[0]", reg.into());
                            
                                
                                let reg = self.foo_7(1).read()?;
                                
                                callback(7 + 1 * 1000, "foo_7[1]", reg.into());
                            
                                
                                let reg = self.foo_7(2).read()?;
                                
                                callback(7 + 2 * 1000, "foo_7[2]", reg.into());
                            
                                
                                let reg = self.foo_7(3).read()?;
                                
                                callback(7 + 3 * 1000, "foo_7[3]", reg.into());
                            
                                
                                let reg = self.foo_7(4).read()?;
                                
                                callback(7 + 4 * 1000, "foo_7[4]", reg.into());
                            
                                
                                let reg = self.foo_7(5).read()?;
                                
                                callback(7 + 5 * 1000, "foo_7[5]", reg.into());
                            
                                
                                let reg = self.foo_7(6).read()?;
                                
                                callback(7 + 6 * 1000, "foo_7[6]", reg.into());
                            
                                
                                let reg = self.foo_7(7).read()?;
                                
                                callback(7 + 7 * 1000, "foo_7[7]", reg.into());
                            
                                
                                let reg = self.foo_7(8).read()?;
                                
                                callback(7 + 8 * 1000, "foo_7[8]", reg.into());
                            
                                
                                let reg = self.foo_7(9).read()?;
                                
                                callback(7 + 9 * 1000, "foo_7[9]", reg.into());
                            
                                
                                let reg = self.foo_7(10).read()?;
                                
                                callback(7 + 10 * 1000, "foo_7[10]", reg.into());
                            
                                
                                let reg = self.foo_7(11).read()?;
                                
                                callback(7 + 11 * 1000, "foo_7[11]", reg.into());
                            
                                
                                let reg = self.foo_7(12).read()?;
                                
                                callback(7 + 12 * 1000, "foo_7[12]", reg.into());
                            
                                
                                let reg = self.foo_7(13).read()?;
                                
                                callback(7 + 13 * 1000, "foo_7[13]", reg.into());
                            
                                
                                let reg = self.foo_7(14).read()?;
                                
                                callback(7 + 14 * 1000, "foo_7[14]", reg.into());
                            
                                
                                let reg = self.foo_7(15).read()?;
                                
                                callback(7 + 15 * 1000, "foo_7[15]", reg.into());
                            
                                
                                let reg = self.foo_7(16).read()?;
                                
                                callback(7 + 16 * 1000, "foo_7[16]", reg.into());
                            
                                
                                let reg = self.foo_7(17).read()?;
                                
                                callback(7 + 17 * 1000, "foo_7[17]", reg.into());
                            
                                
                                let reg = self.foo_7(18).read()?;
                                
                                callback(7 + 18 * 1000, "foo_7[18]", reg.into());
                            
                                
                                let reg = self.foo_7(19).read()?;
                                
                                callback(7 + 19 * 1000, "foo_7[19]", reg.into());
                            
                                
                                let reg = self.foo_7(20).read()?;
                                
                                callback(7 + 20 * 1000, "foo_7[20]", reg.into());
                            
                                
                                let reg = self.foo_7(21).read()?;
                                
                                callback(7 + 21 * 1000, "foo_7[21]", reg.into());
                            
                                
                                let reg = self.foo_7(22).read()?;
                                
                                callback(7 + 22 * 1000, "foo_7[22]", reg.into());
                            
                                
                                let reg = self.foo_7(23).read()?;
                                
                                callback(7 + 23 * 1000, "foo_7[23]", reg.into());
                            
                                
                                let reg = self.foo_7(24).read()?;
                                
                                callback(7 + 24 * 1000, "foo_7[24]", reg.into());
                            
                                
                                let reg = self.foo_7(25).read()?;
                                
                                callback(7 + 25 * 1000, "foo_7[25]", reg.into());
                            
                                
                                let reg = self.foo_7(26).read()?;
                                
                                callback(7 + 26 * 1000, "foo_7[26]", reg.into());
                            
                                
                                let reg = self.foo_7(27).read()?;
                                
                                callback(7 + 27 * 1000, "foo_7[27]", reg.into());
                            
                                
                                let reg = self.foo_7(28).read()?;
                                
                                callback(7 + 28 * 1000, "foo_7[28]", reg.into());
                            
                                
                                let reg = self.foo_7(29).read()?;
                                
                                callback(7 + 29 * 1000, "foo_7[29]", reg.into());
                            
                                
                                let reg = self.foo_7(30).read()?;
                                
                                callback(7 + 30 * 1000, "foo_7[30]", reg.into());
                            
                                
                                let reg = self.foo_7(31).read()?;
                                
                                callback(7 + 31 * 1000, "foo_7[31]", reg.into());
                            
                                
                                let reg = self.foo_7(32).read()?;
                                
                                callback(7 + 32 * 1000, "foo_7[32]", reg.into());
                            
                                
                                let reg = self.foo_7(33).read()?;
                                
                                callback(7 + 33 * 1000, "foo_7[33]", reg.into());
                            
                                
                                let reg = self.foo_7(34).read()?;
                                
                                callback(7 + 34 * 1000, "foo_7[34]", reg.into());
                            
                                
                                let reg = self.foo_7(35).read()?;
                                
                                callback(7 + 35 * 1000, "foo_7[35]", reg.into());
                            
                                
                                let reg = self.foo_7(36).read()?;
                                
                                callback(7 + 36 * 1000, "foo_7[36]", reg.into());
                            
                                
                                let reg = self.foo_7(37).read()?;
                                
                                callback(7 + 37 * 1000, "foo_7[37]", reg.into());
                            
                                
                                let reg = self.foo_7(38).read()?;
                                
                                callback(7 + 38 * 1000, "foo_7[38]", reg.into());
                            
                                
                                let reg = self.foo_7(39).read()?;
                                
                                callback(7 + 39 * 1000, "foo_7[39]", reg.into());
                            
                                
                                let reg = self.foo_7(40).read()?;
                                
                                callback(7 + 40 * 1000, "foo_7[40]", reg.into());
                            
                                
                                let reg = self.foo_7(41).read()?;
                                
                                callback(7 + 41 * 1000, "foo_7[41]", reg.into());
                            
                                
                                let reg = self.foo_7(42).read()?;
                                
                                callback(7 + 42 * 1000, "foo_7[42]", reg.into());
                            
                                
                                let reg = self.foo_7(43).read()?;
                                
                                callback(7 + 43 * 1000, "foo_7[43]", reg.into());
                            
                                
                                let reg = self.foo_7(44).read()?;
                                
                                callback(7 + 44 * 1000, "foo_7[44]", reg.into());
                            
                                
                                let reg = self.foo_7(45).read()?;
                                
                                callback(7 + 45 * 1000, "foo_7[45]", reg.into());
                            
                                
                                let reg = self.foo_7(46).read()?;
                                
                                callback(7 + 46 * 1000, "foo_7[46]", reg.into());
                            
                                
                                let reg = self.foo_7(47).read()?;
                                
                                callback(7 + 47 * 1000, "foo_7[47]", reg.into());
                            
                                
                                let reg = self.foo_7(48).read()?;
                                
                                callback(7 + 48 * 1000, "foo_7[48]", reg.into());
                            
                                
                                let reg = self.foo_7(49).read()?;
                                
                                callback(7 + 49 * 1000, "foo_7[49]", reg.into());
                            
                                
                                let reg = self.foo_7(50).read()?;
                                
                                callback(7 + 50 * 1000, "foo_7[50]", reg.into());
                            
                                
                                let reg = self.foo_7(51).read()?;
                                
                                callback(7 + 51 * 1000, "foo_7[51]", reg.into());
                            
                                
                                let reg = self.foo_7(52).read()?;
                                
                                callback(7 + 52 * 1000, "foo_7[52]", reg.into());
                            
                                
                                let reg = self.foo_7(53).read()?;
                                
                                callback(7 + 53 * 1000, "foo_7[53]", reg.into());
                            
                                
                                let reg = self.foo_7(54).read()?;
                                
                                callback(7 + 54 * 1000, "foo_7[54]", reg.into());
                            
                                
                                let reg = self.foo_7(55).read()?;
                                
                                callback(7 + 55 * 1000, "foo_7[55]", reg.into());
                            
                                
                                let reg = self.foo_7(56).read()?;
                                
                                callback(7 + 56 * 1000, "foo_7[56]", reg.into());
                            
                                
                                let reg = self.foo_7(57).read()?;
                                
                                callback(7 + 57 * 1000, "foo_7[57]", reg.into());
                            
                                
                                let reg = self.foo_7(58).read()?;
                                
                                callback(7 + 58 * 1000, "foo_7[58]", reg.into());
                            
                                
                                let reg = self.foo_7(59).read()?;
                                
                                callback(7 + 59 * 1000, "foo_7[59]", reg.into());
                            
                                
                                let reg = self.foo_7(60).read()?;
                                
                                callback(7 + 60 * 1000, "foo_7[60]", reg.into());
                            
                                
                                let reg = self.foo_7(61).read()?;
                                
                                callback(7 + 61 * 1000, "foo_7[61]", reg.into());
                            
                                
                                let reg = self.foo_7(62).read()?;
                                
                                callback(7 + 62 * 1000, "foo_7[62]", reg.into());
                            
                                
                                let reg = self.foo_7(63).read()?;
                                
                                callback(7 + 63 * 1000, "foo_7[63]", reg.into());
                            
                                
                                let reg = self.foo_7(64).read()?;
                                
                                callback(7 + 64 * 1000, "foo_7[64]", reg.into());
                            
                                
                                let reg = self.foo_7(65).read()?;
                                
                                callback(7 + 65 * 1000, "foo_7[65]", reg.into());
                            
                                
                                let reg = self.foo_7(66).read()?;
                                
                                callback(7 + 66 * 1000, "foo_7[66]", reg.into());
                            
                                
                                let reg = self.foo_7(67).read()?;
                                
                                callback(7 + 67 * 1000, "foo_7[67]", reg.into());
                            
                                
                                let reg = self.foo_7(68).read()?;
                                
                                callback(7 + 68 * 1000, "foo_7[68]", reg.into());
                            
                                
                                let reg = self.foo_7(69).read()?;
                                
                                callback(7 + 69 * 1000, "foo_7[69]", reg.into());
                            
                                
                                let reg = self.foo_7(70).read()?;
                                
                                callback(7 + 70 * 1000, "foo_7[70]", reg.into());
                            
                                
                                let reg = self.foo_7(71).read()?;
                                
                                callback(7 + 71 * 1000, "foo_7[71]", reg.into());
                            
                                
                                let reg = self.foo_7(72).read()?;
                                
                                callback(7 + 72 * 1000, "foo_7[72]", reg.into());
                            
                                
                                let reg = self.foo_7(73).read()?;
                                
                                callback(7 + 73 * 1000, "foo_7[73]", reg.into());
                            
                                
                                let reg = self.foo_7(74).read()?;
                                
                                callback(7 + 74 * 1000, "foo_7[74]", reg.into());
                            
                                
                                let reg = self.foo_7(75).read()?;
                                
                                callback(7 + 75 * 1000, "foo_7[75]", reg.into());
                            
                                
                                let reg = self.foo_7(76).read()?;
                                
                                callback(7 + 76 * 1000, "foo_7[76]", reg.into());
                            
                                
                                let reg = self.foo_7(77).read()?;
                                
                                callback(7 + 77 * 1000, "foo_7[77]", reg.into());
                            
                                
                                let reg = self.foo_7(78).read()?;
                                
                                callback(7 + 78 * 1000, "foo_7[78]", reg.into());
                            
                                
                                let reg = self.foo_7(79).read()?;
                                
                                callback(7 + 79 * 1000, "foo_7[79]", reg.into());
                            
                                
                                let reg = self.foo_7(80).read()?;
                                
                                callback(7 + 80 * 1000, "foo_7[80]", reg.into());
                            
                                
                                let reg = self.foo_7(81).read()?;
                                
                                callback(7 + 81 * 1000, "foo_7[81]", reg.into());
                            
                                
                                let reg = self.foo_7(82).read()?;
                                
                                callback(7 + 82 * 1000, "foo_7[82]", reg.into());
                            
                                
                                let reg = self.foo_7(83).read()?;
                                
                                callback(7 + 83 * 1000, "foo_7[83]", reg.into());
                            
                                
                                let reg = self.foo_7(84).read()?;
                                
                                callback(7 + 84 * 1000, "foo_7[84]", reg.into());
                            
                                
                                let reg = self.foo_7(85).read()?;
                                
                                callback(7 + 85 * 1000, "foo_7[85]", reg.into());
                            
                                
                                let reg = self.foo_7(86).read()?;
                                
                                callback(7 + 86 * 1000, "foo_7[86]", reg.into());
                            
                                
                                let reg = self.foo_7(87).read()?;
                                
                                callback(7 + 87 * 1000, "foo_7[87]", reg.into());
                            
                                
                                let reg = self.foo_7(88).read()?;
                                
                                callback(7 + 88 * 1000, "foo_7[88]", reg.into());
                            
                                
                                let reg = self.foo_7(89).read()?;
                                
                                callback(7 + 89 * 1000, "foo_7[89]", reg.into());
                            
                                
                                let reg = self.foo_7(90).read()?;
                                
                                callback(7 + 90 * 1000, "foo_7[90]", reg.into());
                            
                                
                                let reg = self.foo_7(91).read()?;
                                
                                callback(7 + 91 * 1000, "foo_7[91]", reg.into());
                            
                                
                                let reg = self.foo_7(92).read()?;
                                
                                callback(7 + 92 * 1000, "foo_7[92]", reg.into());
                            
                                
                                let reg = self.foo_7(93).read()?;
                                
                                callback(7 + 93 * 1000, "foo_7[93]", reg.into());
                            
                                
                                let reg = self.foo_7(94).read()?;
                                
                                callback(7 + 94 * 1000, "foo_7[94]", reg.into());
                            
                                
                                let reg = self.foo_7(95).read()?;
                                
                                callback(7 + 95 * 1000, "foo_7[95]", reg.into());
                            
                                
                                let reg = self.foo_7(96).read()?;
                                
                                callback(7 + 96 * 1000, "foo_7[96]", reg.into());
                            
                                
                                let reg = self.foo_7(97).read()?;
                                
                                callback(7 + 97 * 1000, "foo_7[97]", reg.into());
                            
                                
                                let reg = self.foo_7(98).read()?;
                                
                                callback(7 + 98 * 1000, "foo_7[98]", reg.into());
                            
                                
                                let reg = self.foo_7(99).read()?;
                                
                                callback(7 + 99 * 1000, "foo_7[99]", reg.into());
                            
                        
                
            
        
            
                
                    
                            
                                
                                let reg = self.foo_8(0).read()?;
                                
                                callback(8 + 0 * 1000, "foo_8[0]", reg.into());
                            
                                
                                let reg = self.foo_8(1).read()?;
                                
                                callback(8 + 1 * 1000, "foo_8[1]", reg.into());
                            
                                
                                let reg = self.foo_8(2).read()?;
                                
                                callback(8 + 2 * 1000, "foo_8[2]", reg.into());
                            
                                
                                let reg = self.foo_8(3).read()?;
                                
                                callback(8 + 3 * 1000, "foo_8[3]", reg.into());
                            
                                
                                let reg = self.foo_8(4).read()?;
                                
                                callback(8 + 4 * 1000, "foo_8[4]", reg.into());
                            
                                
                                let reg = self.foo_8(5).read()?;
                                
                                callback(8 + 5 * 1000, "foo_8[5]", reg.into());
                            
                                
                                let reg = self.foo_8(6).read()?;
                                
                                callback(8 + 6 * 1000, "foo_8[6]", reg.into());
                            
                                
                                let reg = self.foo_8(7).read()?;
                                
                                callback(8 + 7 * 1000, "foo_8[7]", reg.into());
                            
                                
                                let reg = self.foo_8(8).read()?;
                                
                                callback(8 + 8 * 1000, "foo_8[8]", reg.into());
                            
                                
                                let reg = self.foo_8(9).read()?;
                                
                                callback(8 + 9 * 1000, "foo_8[9]", reg.into());
                            
                                
                                let reg = self.foo_8(10).read()?;
                                
                                callback(8 + 10 * 1000, "foo_8[10]", reg.into());
                            
                                
                                let reg = self.foo_8(11).read()?;
                                
                                callback(8 + 11 * 1000, "foo_8[11]", reg.into());
                            
                                
                                let reg = self.foo_8(12).read()?;
                                
                                callback(8 + 12 * 1000, "foo_8[12]", reg.into());
                            
                                
                                let reg = self.foo_8(13).read()?;
                                
                                callback(8 + 13 * 1000, "foo_8[13]", reg.into());
                            
                                
                                let reg = self.foo_8(14).read()?;
                                
                                callback(8 + 14 * 1000, "foo_8[14]", reg.into());
                            
                                
                                let reg = self.foo_8(15).read()?;
                                
                                callback(8 + 15 * 1000, "foo_8[15]", reg.into());
                            
                                
                                let reg = self.foo_8(16).read()?;
                                
                                callback(8 + 16 * 1000, "foo_8[16]", reg.into());
                            
                                
                                let reg = self.foo_8(17).read()?;
                                
                                callback(8 + 17 * 1000, "foo_8[17]", reg.into());
                            
                                
                                let reg = self.foo_8(18).read()?;
                                
                                callback(8 + 18 * 1000, "foo_8[18]", reg.into());
                            
                                
                                let reg = self.foo_8(19).read()?;
                                
                                callback(8 + 19 * 1000, "foo_8[19]", reg.into());
                            
                                
                                let reg = self.foo_8(20).read()?;
                                
                                callback(8 + 20 * 1000, "foo_8[20]", reg.into());
                            
                                
                                let reg = self.foo_8(21).read()?;
                                
                                callback(8 + 21 * 1000, "foo_8[21]", reg.into());
                            
                                
                                let reg = self.foo_8(22).read()?;
                                
                                callback(8 + 22 * 1000, "foo_8[22]", reg.into());
                            
                                
                                let reg = self.foo_8(23).read()?;
                                
                                callback(8 + 23 * 1000, "foo_8[23]", reg.into());
                            
                                
                                let reg = self.foo_8(24).read()?;
                                
                                callback(8 + 24 * 1000, "foo_8[24]", reg.into());
                            
                                
                                let reg = self.foo_8(25).read()?;
                                
                                callback(8 + 25 * 1000, "foo_8[25]", reg.into());
                            
                                
                                let reg = self.foo_8(26).read()?;
                                
                                callback(8 + 26 * 1000, "foo_8[26]", reg.into());
                            
                                
                                let reg = self.foo_8(27).read()?;
                                
                                callback(8 + 27 * 1000, "foo_8[27]", reg.into());
                            
                                
                                let reg = self.foo_8(28).read()?;
                                
                                callback(8 + 28 * 1000, "foo_8[28]", reg.into());
                            
                                
                                let reg = self.foo_8(29).read()?;
                                
                                callback(8 + 29 * 1000, "foo_8[29]", reg.into());
                            
                                
                                let reg = self.foo_8(30).read()?;
                                
                                callback(8 + 30 * 1000, "foo_8[30]", reg.into());
                            
                                
                                let reg = self.foo_8(31).read()?;
                                
                                callback(8 + 31 * 1000, "foo_8[31]", reg.into());
                            
                                
                                let reg = self.foo_8(32).read()?;
                                
                                callback(8 + 32 * 1000, "foo_8[32]", reg.into());
                            
                                
                                let reg = self.foo_8(33).read()?;
                                
                                callback(8 + 33 * 1000, "foo_8[33]", reg.into());
                            
                                
                                let reg = self.foo_8(34).read()?;
                                
                                callback(8 + 34 * 1000, "foo_8[34]", reg.into());
                            
                                
                                let reg = self.foo_8(35).read()?;
                                
                                callback(8 + 35 * 1000, "foo_8[35]", reg.into());
                            
                                
                                let reg = self.foo_8(36).read()?;
                                
                                callback(8 + 36 * 1000, "foo_8[36]", reg.into());
                            
                                
                                let reg = self.foo_8(37).read()?;
                                
                                callback(8 + 37 * 1000, "foo_8[37]", reg.into());
                            
                                
                                let reg = self.foo_8(38).read()?;
                                
                                callback(8 + 38 * 1000, "foo_8[38]", reg.into());
                            
                                
                                let reg = self.foo_8(39).read()?;
                                
                                callback(8 + 39 * 1000, "foo_8[39]", reg.into());
                            
                                
                                let reg = self.foo_8(40).read()?;
                                
                                callback(8 + 40 * 1000, "foo_8[40]", reg.into());
                            
                                
                                let reg = self.foo_8(41).read()?;
                                
                                callback(8 + 41 * 1000, "foo_8[41]", reg.into());
                            
                                
                                let reg = self.foo_8(42).read()?;
                                
                                callback(8 + 42 * 1000, "foo_8[42]", reg.into());
                            
                                
                                let reg = self.foo_8(43).read()?;
                                
                                callback(8 + 43 * 1000, "foo_8[43]", reg.into());
                            
                                
                                let reg = self.foo_8(44).read()?;
                                
                                callback(8 + 44 * 1000, "foo_8[44]", reg.into());
                            
                                
                                let reg = self.foo_8(45).read()?;
                                
                                callback(8 + 45 * 1000, "foo_8[45]", reg.into());
                            
                                
                                let reg = self.foo_8(46).read()?;
                                
                                callback(8 + 46 * 1000, "foo_8[46]", reg.into());
                            
                                
                                let reg = self.foo_8(47).read()?;
                                
                                callback(8 + 47 * 1000, "foo_8[47]", reg.into());
                            
                                
                                let reg = self.foo_8(48).read()?;
                                
                                callback(8 + 48 * 1000, "foo_8[48]", reg.into());
                            
                                
                                let reg = self.foo_8(49).read()?;
                                
                                callback(8 + 49 * 1000, "foo_8[49]", reg.into());
                            
                                
                                let reg = self.foo_8(50).read()?;
                                
                                callback(8 + 50 * 1000, "foo_8[50]", reg.into());
                            
                                
                                let reg = self.foo_8(51).read()?;
                                
                                callback(8 + 51 * 1000, "foo_8[51]", reg.into());
                            
                                
                                let reg = self.foo_8(52).read()?;
                                
                                callback(8 + 52 * 1000, "foo_8[52]", reg.into());
                            
                                
                                let reg = self.foo_8(53).read()?;
                                
                                callback(8 + 53 * 1000, "foo_8[53]", reg.into());
                            
                                
                                let reg = self.foo_8(54).read()?;
                                
                                callback(8 + 54 * 1000, "foo_8[54]", reg.into());
                            
                                
                                let reg = self.foo_8(55).read()?;
                                
                                callback(8 + 55 * 1000, "foo_8[55]", reg.into());
                            
                                
                                let reg = self.foo_8(56).read()?;
                                
                                callback(8 + 56 * 1000, "foo_8[56]", reg.into());
                            
                                
                                let reg = self.foo_8(57).read()?;
                                
                                callback(8 + 57 * 1000, "foo_8[57]", reg.into());
                            
                                
                                let reg = self.foo_8(58).read()?;
                                
                                callback(8 + 58 * 1000, "foo_8[58]", reg.into());
                            
                                
                                let reg = self.foo_8(59).read()?;
                                
                                callback(8 + 59 * 1000, "foo_8[59]", reg.into());
                            
                                
                                let reg = self.foo_8(60).read()?;
                                
                                callback(8 + 60 * 1000, "foo_8[60]", reg.into());
                            
                                
                                let reg = self.foo_8(61).read()?;
                                
                                callback(8 + 61 * 1000, "foo_8[61]", reg.into());
                            
                                
                                let reg = self.foo_8(62).read()?;
                                
                                callback(8 + 62 * 1000, "foo_8[62]", reg.into());
                            
                                
                                let reg = self.foo_8(63).read()?;
                                
                                callback(8 + 63 * 1000, "foo_8[63]", reg.into());
                            
                                
                                let reg = self.foo_8(64).read()?;
                                
                                callback(8 + 64 * 1000, "foo_8[64]", reg.into());
                            
                                
                                let reg = self.foo_8(65).read()?;
                                
                                callback(8 + 65 * 1000, "foo_8[65]", reg.into());
                            
                                
                                let reg = self.foo_8(66).read()?;
                                
                                callback(8 + 66 * 1000, "foo_8[66]", reg.into());
                            
                                
                                let reg = self.foo_8(67).read()?;
                                
                                callback(8 + 67 * 1000, "foo_8[67]", reg.into());
                            
                                
                                let reg = self.foo_8(68).read()?;
                                
                                callback(8 + 68 * 1000, "foo_8[68]", reg.into());
                            
                                
                                let reg = self.foo_8(69).read()?;
                                
                                callback(8 + 69 * 1000, "foo_8[69]", reg.into());
                            
                                
                                let reg = self.foo_8(70).read()?;
                                
                                callback(8 + 70 * 1000, "foo_8[70]", reg.into());
                            
                                
                                let reg = self.foo_8(71).read()?;
                                
                                callback(8 + 71 * 1000, "foo_8[71]", reg.into());
                            
                                
                                let reg = self.foo_8(72).read()?;
                                
                                callback(8 + 72 * 1000, "foo_8[72]", reg.into());
                            
                                
                                let reg = self.foo_8(73).read()?;
                                
                                callback(8 + 73 * 1000, "foo_8[73]", reg.into());
                            
                                
                                let reg = self.foo_8(74).read()?;
                                
                                callback(8 + 74 * 1000, "foo_8[74]", reg.into());
                            
                                
                                let reg = self.foo_8(75).read()?;
                                
                                callback(8 + 75 * 1000, "foo_8[75]", reg.into());
                            
                                
                                let reg = self.foo_8(76).read()?;
                                
                                callback(8 + 76 * 1000, "foo_8[76]", reg.into());
                            
                                
                                let reg = self.foo_8(77).read()?;
                                
                                callback(8 + 77 * 1000, "foo_8[77]", reg.into());
                            
                                
                                let reg = self.foo_8(78).read()?;
                                
                                callback(8 + 78 * 1000, "foo_8[78]", reg.into());
                            
                                
                                let reg = self.foo_8(79).read()?;
                                
                                callback(8 + 79 * 1000, "foo_8[79]", reg.into());
                            
                                
                                let reg = self.foo_8(80).read()?;
                                
                                callback(8 + 80 * 1000, "foo_8[80]", reg.into());
                            
                                
                                let reg = self.foo_8(81).read()?;
                                
                                callback(8 + 81 * 1000, "foo_8[81]", reg.into());
                            
                                
                                let reg = self.foo_8(82).read()?;
                                
                                callback(8 + 82 * 1000, "foo_8[82]", reg.into());
                            
                                
                                let reg = self.foo_8(83).read()?;
                                
                                callback(8 + 83 * 1000, "foo_8[83]", reg.into());
                            
                                
                                let reg = self.foo_8(84).read()?;
                                
                                callback(8 + 84 * 1000, "foo_8[84]", reg.into());
                            
                                
                                let reg = self.foo_8(85).read()?;
                                
                                callback(8 + 85 * 1000, "foo_8[85]", reg.into());
                            
                                
                                let reg = self.foo_8(86).read()?;
                                
                                callback(8 + 86 * 1000, "foo_8[86]", reg.into());
                            
                                
                                let reg = self.foo_8(87).read()?;
                                
                                callback(8 + 87 * 1000, "foo_8[87]", reg.into());
                            
                                
                                let reg = self.foo_8(88).read()?;
                                
                                callback(8 + 88 * 1000, "foo_8[88]", reg.into());
                            
                                
                                let reg = self.foo_8(89).read()?;
                                
                                callback(8 + 89 * 1000, "foo_8[89]", reg.into());
                            
                                
                                let reg = self.foo_8(90).read()?;
                                
                                callback(8 + 90 * 1000, "foo_8[90]", reg.into());
                            
                                
                                let reg = self.foo_8(91).read()?;
                                
                                callback(8 + 91 * 1000, "foo_8[91]", reg.into());
                            
                                
                                let reg = self.foo_8(92).read()?;
                                
                                callback(8 + 92 * 1000, "foo_8[92]", reg.into());
                            
                                
                                let reg = self.foo_8(93).read()?;
                                
                                callback(8 + 93 * 1000, "foo_8[93]", reg.into());
                            
                                
                                let reg = self.foo_8(94).read()?;
                                
                                callback(8 + 94 * 1000, "foo_8[94]", reg.into());
                            
                                
                                let reg = self.foo_8(95).read()?;
                                
                                callback(8 + 95 * 1000, "foo_8[95]", reg.into());
                            
                                
                                let reg = self.foo_8(96).read()?;
                                
                                callback(8 + 96 * 1000, "foo_8[96]", reg.into());
                            
                                
                                let reg = self.foo_8(97).read()?;
                                
                                callback(8 + 97 * 1000, "foo_8[97]", reg.into());
                            
                                
                                let reg = self.foo_8(98).read()?;
                                
                                callback(8 + 98 * 1000, "foo_8[98]", reg.into());
                            
                                
                                let reg = self.foo_8(99).read()?;
                                
                                callback(8 + 99 * 1000, "foo_8[99]", reg.into());
                            
                        
                
            
        
            
                
                    
                            
                                
                                let reg = self.foo_9(0).read()?;
                                
                                callback(9 + 0 * 1000, "foo_9[0]", reg.into());
                            
                                
                                let reg = self.foo_9(1).read()?;
                                
                                callback(9 + 1 * 1000, "foo_9[1]", reg.into());
                            
                                
                                let reg = self.foo_9(2).read()?;
                                
                                callback(9 + 2 * 1000, "foo_9[2]", reg.into());
                            
                                
                                let reg = self.foo_9(3).read()?;
                                
                                callback(9 + 3 * 1000, "foo_9[3]", reg.into());
                            
                                
                                let reg = self.foo_9(4).read()?;
                                
                                callback(9 + 4 * 1000, "foo_9[4]", reg.into());
                            
                                
                                let reg = self.foo_9(5).read()?;
                                
                                callback(9 + 5 * 1000, "foo_9[5]", reg.into());
                            
                                
                                let reg = self.foo_9(6).read()?;
                                
                                callback(9 + 6 * 1000, "foo_9[6]", reg.into());
                            
                                
                                let reg = self.foo_9(7).read()?;
                                
                                callback(9 + 7 * 1000, "foo_9[7]", reg.into());
                            
                                
                                let reg = self.foo_9(8).read()?;
                                
                                callback(9 + 8 * 1000, "foo_9[8]", reg.into());
                            
                                
                                let reg = self.foo_9(9).read()?;
                                
                                callback(9 + 9 * 1000, "foo_9[9]", reg.into());
                            
                                
                                let reg = self.foo_9(10).read()?;
                                
                                callback(9 + 10 * 1000, "foo_9[10]", reg.into());
                            
                                
                                let reg = self.foo_9(11).read()?;
                                
                                callback(9 + 11 * 1000, "foo_9[11]", reg.into());
                            
                                
                                let reg = self.foo_9(12).read()?;
                                
                                callback(9 + 12 * 1000, "foo_9[12]", reg.into());
                            
                                
                                let reg = self.foo_9(13).read()?;
                                
                                callback(9 + 13 * 1000, "foo_9[13]", reg.into());
                            
                                
                                let reg = self.foo_9(14).read()?;
                                
                                callback(9 + 14 * 1000, "foo_9[14]", reg.into());
                            
                                
                                let reg = self.foo_9(15).read()?;
                                
                                callback(9 + 15 * 1000, "foo_9[15]", reg.into());
                            
                                
                                let reg = self.foo_9(16).read()?;
                                
                                callback(9 + 16 * 1000, "foo_9[16]", reg.into());
                            
                                
                                let reg = self.foo_9(17).read()?;
                                
                                callback(9 + 17 * 1000, "foo_9[17]", reg.into());
                            
                                
                                let reg = self.foo_9(18).read()?;
                                
                                callback(9 + 18 * 1000, "foo_9[18]", reg.into());
                            
                                
                                let reg = self.foo_9(19).read()?;
                                
                                callback(9 + 19 * 1000, "foo_9[19]", reg.into());
                            
                                
                                let reg = self.foo_9(20).read()?;
                                
                                callback(9 + 20 * 1000, "foo_9[20]", reg.into());
                            
                                
                                let reg = self.foo_9(21).read()?;
                                
                                callback(9 + 21 * 1000, "foo_9[21]", reg.into());
                            
                                
                                let reg = self.foo_9(22).read()?;
                                
                                callback(9 + 22 * 1000, "foo_9[22]", reg.into());
                            
                                
                                let reg = self.foo_9(23).read()?;
                                
                                callback(9 + 23 * 1000, "foo_9[23]", reg.into());
                            
                                
                                let reg = self.foo_9(24).read()?;
                                
                                callback(9 + 24 * 1000, "foo_9[24]", reg.into());
                            
                                
                                let reg = self.foo_9(25).read()?;
                                
                                callback(9 + 25 * 1000, "foo_9[25]", reg.into());
                            
                                
                                let reg = self.foo_9(26).read()?;
                                
                                callback(9 + 26 * 1000, "foo_9[26]", reg.into());
                            
                                
                                let reg = self.foo_9(27).read()?;
                                
                                callback(9 + 27 * 1000, "foo_9[27]", reg.into());
                            
                                
                                let reg = self.foo_9(28).read()?;
                                
                                callback(9 + 28 * 1000, "foo_9[28]", reg.into());
                            
                                
                                let reg = self.foo_9(29).read()?;
                                
                                callback(9 + 29 * 1000, "foo_9[29]", reg.into());
                            
                                
                                let reg = self.foo_9(30).read()?;
                                
                                callback(9 + 30 * 1000, "foo_9[30]", reg.into());
                            
                                
                                let reg = self.foo_9(31).read()?;
                                
                                callback(9 + 31 * 1000, "foo_9[31]", reg.into());
                            
                                
                                let reg = self.foo_9(32).read()?;
                                
                                callback(9 + 32 * 1000, "foo_9[32]", reg.into());
                            
                                
                                let reg = self.foo_9(33).read()?;
                                
                                callback(9 + 33 * 1000, "foo_9[33]", reg.into());
                            
                                
                                let reg = self.foo_9(34).read()?;
                                
                                callback(9 + 34 * 1000, "foo_9[34]", reg.into());
                            
                                
                                let reg = self.foo_9(35).read()?;
                                
                                callback(9 + 35 * 1000, "foo_9[35]", reg.into());
                            
                                
                                let reg = self.foo_9(36).read()?;
                                
                                callback(9 + 36 * 1000, "foo_9[36]", reg.into());
                            
                                
                                let reg = self.foo_9(37).read()?;
                                
                                callback(9 + 37 * 1000, "foo_9[37]", reg.into());
                            
                                
                                let reg = self.foo_9(38).read()?;
                                
                                callback(9 + 38 * 1000, "foo_9[38]", reg.into());
                            
                                
                                let reg = self.foo_9(39).read()?;
                                
                                callback(9 + 39 * 1000, "foo_9[39]", reg.into());
                            
                                
                                let reg = self.foo_9(40).read()?;
                                
                                callback(9 + 40 * 1000, "foo_9[40]", reg.into());
                            
                                
                                let reg = self.foo_9(41).read()?;
                                
                                callback(9 + 41 * 1000, "foo_9[41]", reg.into());
                            
                                
                                let reg = self.foo_9(42).read()?;
                                
                                callback(9 + 42 * 1000, "foo_9[42]", reg.into());
                            
                                
                                let reg = self.foo_9(43).read()?;
                                
                                callback(9 + 43 * 1000, "foo_9[43]", reg.into());
                            
                                
                                let reg = self.foo_9(44).read()?;
                                
                                callback(9 + 44 * 1000, "foo_9[44]", reg.into());
                            
                                
                                let reg = self.foo_9(45).read()?;
                                
                                callback(9 + 45 * 1000, "foo_9[45]", reg.into());
                            
                                
                                let reg = self.foo_9(46).read()?;
                                
                                callback(9 + 46 * 1000, "foo_9[46]", reg.into());
                            
                                
                                let reg = self.foo_9(47).read()?;
                                
                                callback(9 + 47 * 1000, "foo_9[47]", reg.into());
                            
                                
                                let reg = self.foo_9(48).read()?;
                                
                                callback(9 + 48 * 1000, "foo_9[48]", reg.into());
                            
                                
                                let reg = self.foo_9(49).read()?;
                                
                                callback(9 + 49 * 1000, "foo_9[49]", reg.into());
                            
                                
                                let reg = self.foo_9(50).read()?;
                                
                                callback(9 + 50 * 1000, "foo_9[50]", reg.into());
                            
                                
                                let reg = self.foo_9(51).read()?;
                                
                                callback(9 + 51 * 1000, "foo_9[51]", reg.into());
                            
                                
                                let reg = self.foo_9(52).read()?;
                                
                                callback(9 + 52 * 1000, "foo_9[52]", reg.into());
                            
                                
                                let reg = self.foo_9(53).read()?;
                                
                                callback(9 + 53 * 1000, "foo_9[53]", reg.into());
                            
                                
                                let reg = self.foo_9(54).read()?;
                                
                                callback(9 + 54 * 1000, "foo_9[54]", reg.into());
                            
                                
                                let reg = self.foo_9(55).read()?;
                                
                                callback(9 + 55 * 1000, "foo_9[55]", reg.into());
                            
                                
                                let reg = self.foo_9(56).read()?;
                                
                                callback(9 + 56 * 1000, "foo_9[56]", reg.into());
                            
                                
                                let reg = self.foo_9(57).read()?;
                                
                                callback(9 + 57 * 1000, "foo_9[57]", reg.into());
                            
                                
                                let reg = self.foo_9(58).read()?;
                                
                                callback(9 + 58 * 1000, "foo_9[58]", reg.into());
                            
                                
                                let reg = self.foo_9(59).read()?;
                                
                                callback(9 + 59 * 1000, "foo_9[59]", reg.into());
                            
                                
                                let reg = self.foo_9(60).read()?;
                                
                                callback(9 + 60 * 1000, "foo_9[60]", reg.into());
                            
                                
                                let reg = self.foo_9(61).read()?;
                                
                                callback(9 + 61 * 1000, "foo_9[61]", reg.into());
                            
                                
                                let reg = self.foo_9(62).read()?;
                                
                                callback(9 + 62 * 1000, "foo_9[62]", reg.into());
                            
                                
                                let reg = self.foo_9(63).read()?;
                                
                                callback(9 + 63 * 1000, "foo_9[63]", reg.into());
                            
                                
                                let reg = self.foo_9(64).read()?;
                                
                                callback(9 + 64 * 1000, "foo_9[64]", reg.into());
                            
                                
                                let reg = self.foo_9(65).read()?;
                                
                                callback(9 + 65 * 1000, "foo_9[65]", reg.into());
                            
                                
                                let reg = self.foo_9(66).read()?;
                                
                                callback(9 + 66 * 1000, "foo_9[66]", reg.into());
                            
                                
                                let reg = self.foo_9(67).read()?;
                                
                                callback(9 + 67 * 1000, "foo_9[67]", reg.into());
                            
                                
                                let reg = self.foo_9(68).read()?;
                                
                                callback(9 + 68 * 1000, "foo_9[68]", reg.into());
                            
                                
                                let reg = self.foo_9(69).read()?;
                                
                                callback(9 + 69 * 1000, "foo_9[69]", reg.into());
                            
                                
                                let reg = self.foo_9(70).read()?;
                                
                                callback(9 + 70 * 1000, "foo_9[70]", reg.into());
                            
                                
                                let reg = self.foo_9(71).read()?;
                                
                                callback(9 + 71 * 1000, "foo_9[71]", reg.into());
                            
                                
                                let reg = self.foo_9(72).read()?;
                                
                                callback(9 + 72 * 1000, "foo_9[72]", reg.into());
                            
                                
                                let reg = self.foo_9(73).read()?;
                                
                                callback(9 + 73 * 1000, "foo_9[73]", reg.into());
                            
                                
                                let reg = self.foo_9(74).read()?;
                                
                                callback(9 + 74 * 1000, "foo_9[74]", reg.into());
                            
                                
                                let reg = self.foo_9(75).read()?;
                                
                                callback(9 + 75 * 1000, "foo_9[75]", reg.into());
                            
                                
                                let reg = self.foo_9(76).read()?;
                                
                                callback(9 + 76 * 1000, "foo_9[76]", reg.into());
                            
                                
                                let reg = self.foo_9(77).read()?;
                                
                                callback(9 + 77 * 1000, "foo_9[77]", reg.into());
                            
                                
                                let reg = self.foo_9(78).read()?;
                                
                                callback(9 + 78 * 1000, "foo_9[78]", reg.into());
                            
                                
                                let reg = self.foo_9(79).read()?;
                                
                                callback(9 + 79 * 1000, "foo_9[79]", reg.into());
                            
                                
                                let reg = self.foo_9(80).read()?;
                                
                                callback(9 + 80 * 1000, "foo_9[80]", reg.into());
                            
                                
                                let reg = self.foo_9(81).read()?;
                                
                                callback(9 + 81 * 1000, "foo_9[81]", reg.into());
                            
                                
                                let reg = self.foo_9(82).read()?;
                                
                                callback(9 + 82 * 1000, "foo_9[82]", reg.into());
                            
                                
                                let reg = self.foo_9(83).read()?;
                                
                                callback(9 + 83 * 1000, "foo_9[83]", reg.into());
                            
                                
                                let reg = self.foo_9(84).read()?;
                                
                                callback(9 + 84 * 1000, "foo_9[84]", reg.into());
                            
                                
                                let reg = self.foo_9(85).read()?;
                                
                                callback(9 + 85 * 1000, "foo_9[85]", reg.into());
                            
                                
                                let reg = self.foo_9(86).read()?;
                                
                                callback(9 + 86 * 1000, "foo_9[86]", reg.into());
                            
                                
                                let reg = self.foo_9(87).read()?;
                                
                                callback(9 + 87 * 1000, "foo_9[87]", reg.into());
                            
                                
                                let reg = self.foo_9(88).read()?;
                                
                                callback(9 + 88 * 1000, "foo_9[88]", reg.into());
                            
                                
                                let reg = self.foo_9(89).read()?;
                                
                                callback(9 + 89 * 1000, "foo_9[89]", reg.into());
                            
                                
                                let reg = self.foo_9(90).read()?;
                                
                                callback(9 + 90 * 1000, "foo_9[90]", reg.into());
                            
                                
                                let reg = self.foo_9(91).read()?;
                                
                                callback(9 + 91 * 1000, "foo_9[91]", reg.into());
                            
                                
                                let reg = self.foo_9(92).read()?;
                                
                                callback(9 + 92 * 1000, "foo_9[92]", reg.into());
                            
                                
                                let reg = self.foo_9(93).read()?;
                                
                                callback(9 + 93 * 1000, "foo_9[93]", reg.into());
                            
                                
                                let reg = self.foo_9(94).read()?;
                                
                                callback(9 + 94 * 1000, "foo_9[94]", reg.into());
                            
                                
                                let reg = self.foo_9(95).read()?;
                                
                                callback(9 + 95 * 1000, "foo_9[95]", reg.into());
                            
                                
                                let reg = self.foo_9(96).read()?;
                                
                                callback(9 + 96 * 1000, "foo_9[96]", reg.into());
                            
                                
                                let reg = self.foo_9(97).read()?;
                                
                                callback(9 + 97 * 1000, "foo_9[97]", reg.into());
                            
                                
                                let reg = self.foo_9(98).read()?;
                                
                                callback(9 + 98 * 1000, "foo_9[98]", reg.into());
                            
                                
                                let reg = self.foo_9(99).read()?;
                                
                                callback(9 + 99 * 1000, "foo_9[99]", reg.into());
                            
                        
                
            
        
            
                
                    
                            
                                
                                let reg = self.foo_10(0).read()?;
                                
                                callback(10 + 0 * 1000, "foo_10[0]", reg.into());
                            
                                
                                let reg = self.foo_10(1).read()?;
                                
                                callback(10 + 1 * 1000, "foo_10[1]", reg.into());
                            
                                
                                let reg = self.foo_10(2).read()?;
                                
                                callback(10 + 2 * 1000, "foo_10[2]", reg.into());
                            
                                
                                let reg = self.foo_10(3).read()?;
                                
                                callback(10 + 3 * 1000, "foo_10[3]", reg.into());
                            
                                
                                let reg = self.foo_10(4).read()?;
                                
                                callback(10 + 4 * 1000, "foo_10[4]", reg.into());
                            
                                
                                let reg = self.foo_10(5).read()?;
                                
                                callback(10 + 5 * 1000, "foo_10[5]", reg.into());
                            
                                
                                let reg = self.foo_10(6).read()?;
                                
                                callback(10 + 6 * 1000, "foo_10[6]", reg.into());
                            
                                
                                let reg = self.foo_10(7).read()?;
                                
                                callback(10 + 7 * 1000, "foo_10[7]", reg.into());
                            
                                
                                let reg = self.foo_10(8).read()?;
                                
                                callback(10 + 8 * 1000, "foo_10[8]", reg.into());
                            
                                
                                let reg = self.foo_10(9).read()?;
                                
                                callback(10 + 9 * 1000, "foo_10[9]", reg.into());
                            
                                
                                let reg = self.foo_10(10).read()?;
                                
                                callback(10 + 10 * 1000, "foo_10[10]", reg.into());
                            
                                
                                let reg = self.foo_10(11).read()?;
                                
                                callback(10 + 11 * 1000, "foo_10[11]", reg.into());
                            
                                
                                let reg = self.foo_10(12).read()?;
                                
                                callback(10 + 12 * 1000, "foo_10[12]", reg.into());
                            
                                
                                let reg = self.foo_10(13).read()?;
                                
                                callback(10 + 13 * 1000, "foo_10[13]", reg.into());
                            
                                
                                let reg = self.foo_10(14).read()?;
                                
                                callback(10 + 14 * 1000, "foo_10[14]", reg.into());
                            
                                
                                let reg = self.foo_10(15).read()?;
                                
                                callback(10 + 15 * 1000, "foo_10[15]", reg.into());
                            
                                
                                let reg = self.foo_10(16).read()?;
                                
                                callback(10 + 16 * 1000, "foo_10[16]", reg.into());
                            
                                
                                let reg = self.foo_10(17).read()?;
                                
                                callback(10 + 17 * 1000, "foo_10[17]", reg.into());
                            
                                
                                let reg = self.foo_10(18).read()?;
                                
                                callback(10 + 18 * 1000, "foo_10[18]", reg.into());
                            
                                
                                let reg = self.foo_10(19).read()?;
                                
                                callback(10 + 19 * 1000, "foo_10[19]", reg.into());
                            
                                
                                let reg = self.foo_10(20).read()?;
                                
                                callback(10 + 20 * 1000, "foo_10[20]", reg.into());
                            
                                
                                let reg = self.foo_10(21).read()?;
                                
                                callback(10 + 21 * 1000, "foo_10[21]", reg.into());
                            
                                
                                let reg = self.foo_10(22).read()?;
                                
                                callback(10 + 22 * 1000, "foo_10[22]", reg.into());
                            
                                
                                let reg = self.foo_10(23).read()?;
                                
                                callback(10 + 23 * 1000, "foo_10[23]", reg.into());
                            
                                
                                let reg = self.foo_10(24).read()?;
                                
                                callback(10 + 24 * 1000, "foo_10[24]", reg.into());
                            
                                
                                let reg = self.foo_10(25).read()?;
                                
                                callback(10 + 25 * 1000, "foo_10[25]", reg.into());
                            
                                
                                let reg = self.foo_10(26).read()?;
                                
                                callback(10 + 26 * 1000, "foo_10[26]", reg.into());
                            
                                
                                let reg = self.foo_10(27).read()?;
                                
                                callback(10 + 27 * 1000, "foo_10[27]", reg.into());
                            
                                
                                let reg = self.foo_10(28).read()?;
                                
                                callback(10 + 28 * 1000, "foo_10[28]", reg.into());
                            
                                
                                let reg = self.foo_10(29).read()?;
                                
                                callback(10 + 29 * 1000, "foo_10[29]", reg.into());
                            
                                
                                let reg = self.foo_10(30).read()?;
                                
                                callback(10 + 30 * 1000, "foo_10[30]", reg.into());
                            
                                
                                let reg = self.foo_10(31).read()?;
                                
                                callback(10 + 31 * 1000, "foo_10[31]", reg.into());
                            
                                
                                let reg = self.foo_10(32).read()?;
                                
                                callback(10 + 32 * 1000, "foo_10[32]", reg.into());
                            
                                
                                let reg = self.foo_10(33).read()?;
                                
                                callback(10 + 33 * 1000, "foo_10[33]", reg.into());
                            
                                
                                let reg = self.foo_10(34).read()?;
                                
                                callback(10 + 34 * 1000, "foo_10[34]", reg.into());
                            
                                
                                let reg = self.foo_10(35).read()?;
                                
                                callback(10 + 35 * 1000, "foo_10[35]", reg.into());
                            
                                
                                let reg = self.foo_10(36).read()?;
                                
                                callback(10 + 36 * 1000, "foo_10[36]", reg.into());
                            
                                
                                let reg = self.foo_10(37).read()?;
                                
                                callback(10 + 37 * 1000, "foo_10[37]", reg.into());
                            
                                
                                let reg = self.foo_10(38).read()?;
                                
                                callback(10 + 38 * 1000, "foo_10[38]", reg.into());
                            
                                
                                let reg = self.foo_10(39).read()?;
                                
                                callback(10 + 39 * 1000, "foo_10[39]", reg.into());
                            
                                
                                let reg = self.foo_10(40).read()?;
                                
                                callback(10 + 40 * 1000, "foo_10[40]", reg.into());
                            
                                
                                let reg = self.foo_10(41).read()?;
                                
                                callback(10 + 41 * 1000, "foo_10[41]", reg.into());
                            
                                
                                let reg = self.foo_10(42).read()?;
                                
                                callback(10 + 42 * 1000, "foo_10[42]", reg.into());
                            
                                
                                let reg = self.foo_10(43).read()?;
                                
                                callback(10 + 43 * 1000, "foo_10[43]", reg.into());
                            
                                
                                let reg = self.foo_10(44).read()?;
                                
                                callback(10 + 44 * 1000, "foo_10[44]", reg.into());
                            
                                
                                let reg = self.foo_10(45).read()?;
                                
                                callback(10 + 45 * 1000, "foo_10[45]", reg.into());
                            
                                
                                let reg = self.foo_10(46).read()?;
                                
                                callback(10 + 46 * 1000, "foo_10[46]", reg.into());
                            
                                
                                let reg = self.foo_10(47).read()?;
                                
                                callback(10 + 47 * 1000, "foo_10[47]", reg.into());
                            
                                
                                let reg = self.foo_10(48).read()?;
                                
                                callback(10 + 48 * 1000, "foo_10[48]", reg.into());
                            
                                
                                let reg = self.foo_10(49).read()?;
                                
                                callback(10 + 49 * 1000, "foo_10[49]", reg.into());
                            
                                
                                let reg = self.foo_10(50).read()?;
                                
                                callback(10 + 50 * 1000, "foo_10[50]", reg.into());
                            
                                
                                let reg = self.foo_10(51).read()?;
                                
                                callback(10 + 51 * 1000, "foo_10[51]", reg.into());
                            
                                
                                let reg = self.foo_10(52).read()?;
                                
                                callback(10 + 52 * 1000, "foo_10[52]", reg.into());
                            
                                
                                let reg = self.foo_10(53).read()?;
                                
                                callback(10 + 53 * 1000, "foo_10[53]", reg.into());
                            
                                
                                let reg = self.foo_10(54).read()?;
                                
                                callback(10 + 54 * 1000, "foo_10[54]", reg.into());
                            
                                
                                let reg = self.foo_10(55).read()?;
                                
                                callback(10 + 55 * 1000, "foo_10[55]", reg.into());
                            
                                
                                let reg = self.foo_10(56).read()?;
                                
                                callback(10 + 56 * 1000, "foo_10[56]", reg.into());
                            
                                
                                let reg = self.foo_10(57).read()?;
                                
                                callback(10 + 57 * 1000, "foo_10[57]", reg.into());
                            
                                
                                let reg = self.foo_10(58).read()?;
                                
                                callback(10 + 58 * 1000, "foo_10[58]", reg.into());
                            
                                
                                let reg = self.foo_10(59).read()?;
                                
                                callback(10 + 59 * 1000, "foo_10[59]", reg.into());
                            
                                
                                let reg = self.foo_10(60).read()?;
                                
                                callback(10 + 60 * 1000, "foo_10[60]", reg.into());
                            
                                
                                let reg = self.foo_10(61).read()?;
                                
                                callback(10 + 61 * 1000, "foo_10[61]", reg.into());
                            
                                
                                let reg = self.foo_10(62).read()?;
                                
                                callback(10 + 62 * 1000, "foo_10[62]", reg.into());
                            
                                
                                let reg = self.foo_10(63).read()?;
                                
                                callback(10 + 63 * 1000, "foo_10[63]", reg.into());
                            
                                
                                let reg = self.foo_10(64).read()?;
                                
                                callback(10 + 64 * 1000, "foo_10[64]", reg.into());
                            
                                
                                let reg = self.foo_10(65).read()?;
                                
                                callback(10 + 65 * 1000, "foo_10[65]", reg.into());
                            
                                
                                let reg = self.foo_10(66).read()?;
                                
                                callback(10 + 66 * 1000, "foo_10[66]", reg.into());
                            
                                
                                let reg = self.foo_10(67).read()?;
                                
                                callback(10 + 67 * 1000, "foo_10[67]", reg.into());
                            
                                
                                let reg = self.foo_10(68).read()?;
                                
                                callback(10 + 68 * 1000, "foo_10[68]", reg.into());
                            
                                
                                let reg = self.foo_10(69).read()?;
                                
                                callback(10 + 69 * 1000, "foo_10[69]", reg.into());
                            
                                
                                let reg = self.foo_10(70).read()?;
                                
                                callback(10 + 70 * 1000, "foo_10[70]", reg.into());
                            
                                
                                let reg = self.foo_10(71).read()?;
                                
                                callback(10 + 71 * 1000, "foo_10[71]", reg.into());
                            
                                
                                let reg = self.foo_10(72).read()?;
                                
                                callback(10 + 72 * 1000, "foo_10[72]", reg.into());
                            
                                
                                let reg = self.foo_10(73).read()?;
                                
                                callback(10 + 73 * 1000, "foo_10[73]", reg.into());
                            
                                
                                let reg = self.foo_10(74).read()?;
                                
                                callback(10 + 74 * 1000, "foo_10[74]", reg.into());
                            
                                
                                let reg = self.foo_10(75).read()?;
                                
                                callback(10 + 75 * 1000, "foo_10[75]", reg.into());
                            
                                
                                let reg = self.foo_10(76).read()?;
                                
                                callback(10 + 76 * 1000, "foo_10[76]", reg.into());
                            
                                
                                let reg = self.foo_10(77).read()?;
                                
                                callback(10 + 77 * 1000, "foo_10[77]", reg.into());
                            
                                
                                let reg = self.foo_10(78).read()?;
                                
                                callback(10 + 78 * 1000, "foo_10[78]", reg.into());
                            
                                
                                let reg = self.foo_10(79).read()?;
                                
                                callback(10 + 79 * 1000, "foo_10[79]", reg.into());
                            
                                
                                let reg = self.foo_10(80).read()?;
                                
                                callback(10 + 80 * 1000, "foo_10[80]", reg.into());
                            
                                
                                let reg = self.foo_10(81).read()?;
                                
                                callback(10 + 81 * 1000, "foo_10[81]", reg.into());
                            
                                
                                let reg = self.foo_10(82).read()?;
                                
                                callback(10 + 82 * 1000, "foo_10[82]", reg.into());
                            
                                
                                let reg = self.foo_10(83).read()?;
                                
                                callback(10 + 83 * 1000, "foo_10[83]", reg.into());
                            
                                
                                let reg = self.foo_10(84).read()?;
                                
                                callback(10 + 84 * 1000, "foo_10[84]", reg.into());
                            
                                
                                let reg = self.foo_10(85).read()?;
                                
                                callback(10 + 85 * 1000, "foo_10[85]", reg.into());
                            
                                
                                let reg = self.foo_10(86).read()?;
                                
                                callback(10 + 86 * 1000, "foo_10[86]", reg.into());
                            
                                
                                let reg = self.foo_10(87).read()?;
                                
                                callback(10 + 87 * 1000, "foo_10[87]", reg.into());
                            
                                
                                let reg = self.foo_10(88).read()?;
                                
                                callback(10 + 88 * 1000, "foo_10[88]", reg.into());
                            
                                
                                let reg = self.foo_10(89).read()?;
                                
                                callback(10 + 89 * 1000, "foo_10[89]", reg.into());
                            
                                
                                let reg = self.foo_10(90).read()?;
                                
                                callback(10 + 90 * 1000, "foo_10[90]", reg.into());
                            
                                
                                let reg = self.foo_10(91).read()?;
                                
                                callback(10 + 91 * 1000, "foo_10[91]", reg.into());
                            
                                
                                let reg = self.foo_10(92).read()?;
                                
                                callback(10 + 92 * 1000, "foo_10[92]", reg.into());
                            
                                
                                let reg = self.foo_10(93).read()?;
                                
                                callback(10 + 93 * 1000, "foo_10[93]", reg.into());
                            
                                
                                let reg = self.foo_10(94).read()?;
                                
                                callback(10 + 94 * 1000, "foo_10[94]", reg.into());
                            
                                
                                let reg = self.foo_10(95).read()?;
                                
                                callback(10 + 95 * 1000, "foo_10[95]", reg.into());
                            
                                
                                let reg = self.foo_10(96).read()?;
                                
                                callback(10 + 96 * 1000, "foo_10[96]", reg.into());
                            
                                
                                let reg = self.foo_10(97).read()?;
                                
                                callback(10 + 97 * 1000, "foo_10[97]", reg.into());
                            
                                
                                let reg = self.foo_10(98).read()?;
                                
                                callback(10 + 98 * 1000, "foo_10[98]", reg.into());
                            
                                
                                let reg = self.foo_10(99).read()?;
                                
                                callback(10 + 99 * 1000, "foo_10[99]", reg.into());
                            
                        
                
            
        
            
                
                    
                            
                                
                                let reg = self.foo_11(0).read()?;
                                
                                callback(11 + 0 * 1000, "foo_11[0]", reg.into());
                            
                                
                                let reg = self.foo_11(1).read()?;
                                
                                callback(11 + 1 * 1000, "foo_11[1]", reg.into());
                            
                                
                                let reg = self.foo_11(2).read()?;
                                
                                callback(11 + 2 * 1000, "foo_11[2]", reg.into());
                            
                                
                                let reg = self.foo_11(3).read()?;
                                
                                callback(11 + 3 * 1000, "foo_11[3]", reg.into());
                            
                                
                                let reg = self.foo_11(4).read()?;
                                
                                callback(11 + 4 * 1000, "foo_11[4]", reg.into());
                            
                                
                                let reg = self.foo_11(5).read()?;
                                
                                callback(11 + 5 * 1000, "foo_11[5]", reg.into());
                            
                                
                                let reg = self.foo_11(6).read()?;
                                
                                callback(11 + 6 * 1000, "foo_11[6]", reg.into());
                            
                                
                                let reg = self.foo_11(7).read()?;
                                
                                callback(11 + 7 * 1000, "foo_11[7]", reg.into());
                            
                                
                                let reg = self.foo_11(8).read()?;
                                
                                callback(11 + 8 * 1000, "foo_11[8]", reg.into());
                            
                                
                                let reg = self.foo_11(9).read()?;
                                
                                callback(11 + 9 * 1000, "foo_11[9]", reg.into());
                            
                                
                                let reg = self.foo_11(10).read()?;
                                
                                callback(11 + 10 * 1000, "foo_11[10]", reg.into());
                            
                                
                                let reg = self.foo_11(11).read()?;
                                
                                callback(11 + 11 * 1000, "foo_11[11]", reg.into());
                            
                                
                                let reg = self.foo_11(12).read()?;
                                
                                callback(11 + 12 * 1000, "foo_11[12]", reg.into());
                            
                                
                                let reg = self.foo_11(13).read()?;
                                
                                callback(11 + 13 * 1000, "foo_11[13]", reg.into());
                            
                                
                                let reg = self.foo_11(14).read()?;
                                
                                callback(11 + 14 * 1000, "foo_11[14]", reg.into());
                            
                                
                                let reg = self.foo_11(15).read()?;
                                
                                callback(11 + 15 * 1000, "foo_11[15]", reg.into());
                            
                                
                                let reg = self.foo_11(16).read()?;
                                
                                callback(11 + 16 * 1000, "foo_11[16]", reg.into());
                            
                                
                                let reg = self.foo_11(17).read()?;
                                
                                callback(11 + 17 * 1000, "foo_11[17]", reg.into());
                            
                                
                                let reg = self.foo_11(18).read()?;
                                
                                callback(11 + 18 * 1000, "foo_11[18]", reg.into());
                            
                                
                                let reg = self.foo_11(19).read()?;
                                
                                callback(11 + 19 * 1000, "foo_11[19]", reg.into());
                            
                                
                                let reg = self.foo_11(20).read()?;
                                
                                callback(11 + 20 * 1000, "foo_11[20]", reg.into());
                            
                                
                                let reg = self.foo_11(21).read()?;
                                
                                callback(11 + 21 * 1000, "foo_11[21]", reg.into());
                            
                                
                                let reg = self.foo_11(22).read()?;
                                
                                callback(11 + 22 * 1000, "foo_11[22]", reg.into());
                            
                                
                                let reg = self.foo_11(23).read()?;
                                
                                callback(11 + 23 * 1000, "foo_11[23]", reg.into());
                            
                                
                                let reg = self.foo_11(24).read()?;
                                
                                callback(11 + 24 * 1000, "foo_11[24]", reg.into());
                            
                                
                                let reg = self.foo_11(25).read()?;
                                
                                callback(11 + 25 * 1000, "foo_11[25]", reg.into());
                            
                                
                                let reg = self.foo_11(26).read()?;
                                
                                callback(11 + 26 * 1000, "foo_11[26]", reg.into());
                            
                                
                                let reg = self.foo_11(27).read()?;
                                
                                callback(11 + 27 * 1000, "foo_11[27]", reg.into());
                            
                                
                                let reg = self.foo_11(28).read()?;
                                
                                callback(11 + 28 * 1000, "foo_11[28]", reg.into());
                            
                                
                                let reg = self.foo_11(29).read()?;
                                
                                callback(11 + 29 * 1000, "foo_11[29]", reg.into());
                            
                                
                                let reg = self.foo_11(30).read()?;
                                
                                callback(11 + 30 * 1000, "foo_11[30]", reg.into());
                            
                                
                                let reg = self.foo_11(31).read()?;
                                
                                callback(11 + 31 * 1000, "foo_11[31]", reg.into());
                            
                                
                                let reg = self.foo_11(32).read()?;
                                
                                callback(11 + 32 * 1000, "foo_11[32]", reg.into());
                            
                                
                                let reg = self.foo_11(33).read()?;
                                
                                callback(11 + 33 * 1000, "foo_11[33]", reg.into());
                            
                                
                                let reg = self.foo_11(34).read()?;
                                
                                callback(11 + 34 * 1000, "foo_11[34]", reg.into());
                            
                                
                                let reg = self.foo_11(35).read()?;
                                
                                callback(11 + 35 * 1000, "foo_11[35]", reg.into());
                            
                                
                                let reg = self.foo_11(36).read()?;
                                
                                callback(11 + 36 * 1000, "foo_11[36]", reg.into());
                            
                                
                                let reg = self.foo_11(37).read()?;
                                
                                callback(11 + 37 * 1000, "foo_11[37]", reg.into());
                            
                                
                                let reg = self.foo_11(38).read()?;
                                
                                callback(11 + 38 * 1000, "foo_11[38]", reg.into());
                            
                                
                                let reg = self.foo_11(39).read()?;
                                
                                callback(11 + 39 * 1000, "foo_11[39]", reg.into());
                            
                                
                                let reg = self.foo_11(40).read()?;
                                
                                callback(11 + 40 * 1000, "foo_11[40]", reg.into());
                            
                                
                                let reg = self.foo_11(41).read()?;
                                
                                callback(11 + 41 * 1000, "foo_11[41]", reg.into());
                            
                                
                                let reg = self.foo_11(42).read()?;
                                
                                callback(11 + 42 * 1000, "foo_11[42]", reg.into());
                            
                                
                                let reg = self.foo_11(43).read()?;
                                
                                callback(11 + 43 * 1000, "foo_11[43]", reg.into());
                            
                                
                                let reg = self.foo_11(44).read()?;
                                
                                callback(11 + 44 * 1000, "foo_11[44]", reg.into());
                            
                                
                                let reg = self.foo_11(45).read()?;
                                
                                callback(11 + 45 * 1000, "foo_11[45]", reg.into());
                            
                                
                                let reg = self.foo_11(46).read()?;
                                
                                callback(11 + 46 * 1000, "foo_11[46]", reg.into());
                            
                                
                                let reg = self.foo_11(47).read()?;
                                
                                callback(11 + 47 * 1000, "foo_11[47]", reg.into());
                            
                                
                                let reg = self.foo_11(48).read()?;
                                
                                callback(11 + 48 * 1000, "foo_11[48]", reg.into());
                            
                                
                                let reg = self.foo_11(49).read()?;
                                
                                callback(11 + 49 * 1000, "foo_11[49]", reg.into());
                            
                                
                                let reg = self.foo_11(50).read()?;
                                
                                callback(11 + 50 * 1000, "foo_11[50]", reg.into());
                            
                                
                                let reg = self.foo_11(51).read()?;
                                
                                callback(11 + 51 * 1000, "foo_11[51]", reg.into());
                            
                                
                                let reg = self.foo_11(52).read()?;
                                
                                callback(11 + 52 * 1000, "foo_11[52]", reg.into());
                            
                                
                                let reg = self.foo_11(53).read()?;
                                
                                callback(11 + 53 * 1000, "foo_11[53]", reg.into());
                            
                                
                                let reg = self.foo_11(54).read()?;
                                
                                callback(11 + 54 * 1000, "foo_11[54]", reg.into());
                            
                                
                                let reg = self.foo_11(55).read()?;
                                
                                callback(11 + 55 * 1000, "foo_11[55]", reg.into());
                            
                                
                                let reg = self.foo_11(56).read()?;
                                
                                callback(11 + 56 * 1000, "foo_11[56]", reg.into());
                            
                                
                                let reg = self.foo_11(57).read()?;
                                
                                callback(11 + 57 * 1000, "foo_11[57]", reg.into());
                            
                                
                                let reg = self.foo_11(58).read()?;
                                
                                callback(11 + 58 * 1000, "foo_11[58]", reg.into());
                            
                                
                                let reg = self.foo_11(59).read()?;
                                
                                callback(11 + 59 * 1000, "foo_11[59]", reg.into());
                            
                                
                                let reg = self.foo_11(60).read()?;
                                
                                callback(11 + 60 * 1000, "foo_11[60]", reg.into());
                            
                                
                                let reg = self.foo_11(61).read()?;
                                
                                callback(11 + 61 * 1000, "foo_11[61]", reg.into());
                            
                                
                                let reg = self.foo_11(62).read()?;
                                
                                callback(11 + 62 * 1000, "foo_11[62]", reg.into());
                            
                                
                                let reg = self.foo_11(63).read()?;
                                
                                callback(11 + 63 * 1000, "foo_11[63]", reg.into());
                            
                                
                                let reg = self.foo_11(64).read()?;
                                
                                callback(11 + 64 * 1000, "foo_11[64]", reg.into());
                            
                                
                                let reg = self.foo_11(65).read()?;
                                
                                callback(11 + 65 * 1000, "foo_11[65]", reg.into());
                            
                                
                                let reg = self.foo_11(66).read()?;
                                
                                callback(11 + 66 * 1000, "foo_11[66]", reg.into());
                            
                                
                                let reg = self.foo_11(67).read()?;
                                
                                callback(11 + 67 * 1000, "foo_11[67]", reg.into());
                            
                                
                                let reg = self.foo_11(68).read()?;
                                
                                callback(11 + 68 * 1000, "foo_11[68]", reg.into());
                            
                                
                                let reg = self.foo_11(69).read()?;
                                
                                callback(11 + 69 * 1000, "foo_11[69]", reg.into());
                            
                                
                                let reg = self.foo_11(70).read()?;
                                
                                callback(11 + 70 * 1000, "foo_11[70]", reg.into());
                            
                                
                                let reg = self.foo_11(71).read()?;
                                
                                callback(11 + 71 * 1000, "foo_11[71]", reg.into());
                            
                                
                                let reg = self.foo_11(72).read()?;
                                
                                callback(11 + 72 * 1000, "foo_11[72]", reg.into());
                            
                                
                                let reg = self.foo_11(73).read()?;
                                
                                callback(11 + 73 * 1000, "foo_11[73]", reg.into());
                            
                                
                                let reg = self.foo_11(74).read()?;
                                
                                callback(11 + 74 * 1000, "foo_11[74]", reg.into());
                            
                                
                                let reg = self.foo_11(75).read()?;
                                
                                callback(11 + 75 * 1000, "foo_11[75]", reg.into());
                            
                                
                                let reg = self.foo_11(76).read()?;
                                
                                callback(11 + 76 * 1000, "foo_11[76]", reg.into());
                            
                                
                                let reg = self.foo_11(77).read()?;
                                
                                callback(11 + 77 * 1000, "foo_11[77]", reg.into());
                            
                                
                                let reg = self.foo_11(78).read()?;
                                
                                callback(11 + 78 * 1000, "foo_11[78]", reg.into());
                            
                                
                                let reg = self.foo_11(79).read()?;
                                
                                callback(11 + 79 * 1000, "foo_11[79]", reg.into());
                            
                                
                                let reg = self.foo_11(80).read()?;
                                
                                callback(11 + 80 * 1000, "foo_11[80]", reg.into());
                            
                                
                                let reg = self.foo_11(81).read()?;
                                
                                callback(11 + 81 * 1000, "foo_11[81]", reg.into());
                            
                                
                                let reg = self.foo_11(82).read()?;
                                
                                callback(11 + 82 * 1000, "foo_11[82]", reg.into());
                            
                                
                                let reg = self.foo_11(83).read()?;
                                
                                callback(11 + 83 * 1000, "foo_11[83]", reg.into());
                            
                                
                                let reg = self.foo_11(84).read()?;
                                
                                callback(11 + 84 * 1000, "foo_11[84]", reg.into());
                            
                                
                                let reg = self.foo_11(85).read()?;
                                
                                callback(11 + 85 * 1000, "foo_11[85]", reg.into());
                            
                                
                                let reg = self.foo_11(86).read()?;
                                
                                callback(11 + 86 * 1000, "foo_11[86]", reg.into());
                            
                                
                                let reg = self.foo_11(87).read()?;
                                
                                callback(11 + 87 * 1000, "foo_11[87]", reg.into());
                            
                                
                                let reg = self.foo_11(88).read()?;
                                
                                callback(11 + 88 * 1000, "foo_11[88]", reg.into());
                            
                                
                                let reg = self.foo_11(89).read()?;
                                
                                callback(11 + 89 * 1000, "foo_11[89]", reg.into());
                            
                                
                                let reg = self.foo_11(90).read()?;
                                
                                callback(11 + 90 * 1000, "foo_11[90]", reg.into());
                            
                                
                                let reg = self.foo_11(91).read()?;
                                
                                callback(11 + 91 * 1000, "foo_11[91]", reg.into());
                            
                                
                                let reg = self.foo_11(92).read()?;
                                
                                callback(11 + 92 * 1000, "foo_11[92]", reg.into());
                            
                                
                                let reg = self.foo_11(93).read()?;
                                
                                callback(11 + 93 * 1000, "foo_11[93]", reg.into());
                            
                                
                                let reg = self.foo_11(94).read()?;
                                
                                callback(11 + 94 * 1000, "foo_11[94]", reg.into());
                            
                                
                                let reg = self.foo_11(95).read()?;
                                
                                callback(11 + 95 * 1000, "foo_11[95]", reg.into());
                            
                                
                                let reg = self.foo_11(96).read()?;
                                
                                callback(11 + 96 * 1000, "foo_11[96]", reg.into());
                            
                                
                                let reg = self.foo_11(97).read()?;
                                
                                callback(11 + 97 * 1000, "foo_11[97]", reg.into());
                            
                                
                                let reg = self.foo_11(98).read()?;
                                
                                callback(11 + 98 * 1000, "foo_11[98]", reg.into());
                            
                                
                                let reg = self.foo_11(99).read()?;
                                
                                callback(11 + 99 * 1000, "foo_11[99]", reg.into());
                            
                        
                
            
        

        Ok(())
    }
    
    /// Read all readable register values in this block from the device.
    /// The callback is called for each of them.
    /// Any registers in child blocks are not included.
    ///
    /// The callback has three arguments:
    ///
    /// - The address of the register
    /// - The name of the register (with index for repeated registers)
    /// - The read value from the register
    ///
    /// This is useful for e.g. debug printing all values.
    /// The given [field_sets::FieldSetValue] has a Debug and Format implementation that forwards to the concrete type
    /// the lies within so it can be printed without matching on it.
    #[allow(unused_mut)]
    #[allow(unused_variables)]
    pub async fn read_all_registers_async(
        &mut self,
        mut callback: impl FnMut(u32, &'static str, field_sets::FieldSetValue),
    ) -> Result<(), I::Error>
    where
        I: ::device_driver::AsyncRegisterInterface<AddressType = u32>,
    {
        
            
                
                    
                            
                                
                                let reg = self.foo_0(0).read_async().await?;
                                
                                callback(0 + 0 * 1000, "foo_0[0]", reg.into());
                            
                                
                                let reg = self.foo_0(1).read_async().await?;
                                
                                callback(0 + 1 * 1000, "foo_0[1]", reg.into());
                            
                                
                                let reg = self.foo_0(2).read_async().await?;
                                
                                callback(0 + 2 * 1000, "foo_0[2]", reg.into());
                            
                                
                                let reg = self.foo_0(3).read_async().await?;
                                
                                callback(0 + 3 * 1000, "foo_0[3]", reg.into());
                            
                                
                                let reg = self.foo_0(4).read_async().await?;
                                
                                callback(0 + 4 * 1000, "foo_0[4]", reg.into());
                            
                                
                                let reg = self.foo_0(5).read_async().await?;
                                
                                callback(0 + 5 * 1000, "foo_0[5]", reg.into());
                            
                                
                                let reg = self.foo_0(6).read_async().await?;
                                
                                callback(0 + 6 * 1000, "foo_0[6]", reg.into());
                            
                                
                                let reg = self.foo_0(7).read_async().await?;
                                
                                callback(0 + 7 * 1000, "foo_0[7]", reg.into());
                            
                                
                                let reg = self.foo_0(8).read_async().await?;
                                
                                callback(0 + 8 * 1000, "foo_0[8]", reg.into());
                            
                                
                                let reg = self.foo_0(9).read_async().await?;
                                
                                callback(0 + 9 * 1000, "foo_0[9]", reg.into());
                            
                                
                                let reg = self.foo_0(10).read_async().await?;
                                
                                callback(0 + 10 * 1000, "foo_0[10]", reg.into());
                            
                                
                                let reg = self.foo_0(11).read_async().await?;
                                
                                callback(0 + 11 * 1000, "foo_0[11]", reg.into());
                            
                                
                                let reg = self.foo_0(12).read_async().await?;
                                
                                callback(0 + 12 * 1000, "foo_0[12]", reg.into());
                            
                                
                                let reg = self.foo_0(13).read_async().await?;
                                
                                callback(0 + 13 * 1000, "foo_0[13]", reg.into());
                            
                                
                                let reg = self.foo_0(14).read_async().await?;
                                
                                callback(0 + 14 * 1000, "foo_0[14]", reg.into());
                            
                                
                                let reg = self.foo_0(15).read_async().await?;
                                
                                callback(0 + 15 * 1000, "foo_0[15]", reg.into());
                            
                                
                                let reg = self.foo_0(16).read_async().await?;
                                
                                callback(0 + 16 * 1000, "foo_0[16]", reg.into());
                            
                                
                                let reg = self.foo_0(17).read_async().await?;
                                
                                callback(0 + 17 * 1000, "foo_0[17]", reg.into());
                            
                                
                                let reg = self.foo_0(18).read_async().await?;
                                
                                callback(0 + 18 * 1000, "foo_0[18]", reg.into());
                            
                                
                                let reg = self.foo_0(19).read_async().await?;
                                
                                callback(0 + 19 * 1000, "foo_0[19]", reg.into());
                            
                                
                                let reg = self.foo_0(20).read_async().await?;
                                
                                callback(0 + 20 * 1000, "foo_0[20]", reg.into());
                            
                                
                                let reg = self.foo_0(21).read_async().await?;
                                
                                callback(0 + 21 * 1000, "foo_0[21]", reg.into());
                            
                                
                                let reg = self.foo_0(22).read_async().await?;
                                
                                callback(0 + 22 * 1000, "foo_0[22]", reg.into());
                            
                                
                                let reg = self.foo_0(23).read_async().await?;
                                
                                callback(0 + 23 * 1000, "foo_0[23]", reg.into());
                            
                                
                                let reg = self.foo_0(24).read_async().await?;
                                
                                callback(0 + 24 * 1000, "foo_0[24]", reg.into());
                            
                                
                                let reg = self.foo_0(25).read_async().await?;
                                
                                callback(0 + 25 * 1000, "foo_0[25]", reg.into());
                            
                                
                                let reg = self.foo_0(26).read_async().await?;
                                
                                callback(0 + 26 * 1000, "foo_0[26]", reg.into());
                            
                                
                                let reg = self.foo_0(27).read_async().await?;
                                
                                callback(0 + 27 * 1000, "foo_0[27]", reg.into());
                            
                                
                                let reg = self.foo_0(28).read_async().await?;
                                
                                callback(0 + 28 * 1000, "foo_0[28]", reg.into());
                            
                                
                                let reg = self.foo_0(29).read_async().await?;
                                
                                callback(0 + 29 * 1000, "foo_0[29]", reg.into());
                            
                                
                                let reg = self.foo_0(30).read_async().await?;
                                
                                callback(0 + 30 * 1000, "foo_0[30]", reg.into());
                            
                                
                                let reg = self.foo_0(31).read_async().await?;
                                
                                callback(0 + 31 * 1000, "foo_0[31]", reg.into());
                            
                                
                                let reg = self.foo_0(32).read_async().await?;
                                
                                callback(0 + 32 * 1000, "foo_0[32]", reg.into());
                            
                                
                                let reg = self.foo_0(33).read_async().await?;
                                
                                callback(0 + 33 * 1000, "foo_0[33]", reg.into());
                            
                                
                                let reg = self.foo_0(34).read_async().await?;
                                
                                callback(0 + 34 * 1000, "foo_0[34]", reg.into());
                            
                                
                                let reg = self.foo_0(35).read_async().await?;
                                
                                callback(0 + 35 * 1000, "foo_0[35]", reg.into());
                            
                                
                                let reg = self.foo_0(36).read_async().await?;
                                
                                callback(0 + 36 * 1000, "foo_0[36]", reg.into());
                            
                                
                                let reg = self.foo_0(37).read_async().await?;
                                
                                callback(0 + 37 * 1000, "foo_0[37]", reg.into());
                            
                                
                                let reg = self.foo_0(38).read_async().await?;
                                
                                callback(0 + 38 * 1000, "foo_0[38]", reg.into());
                            
                                
                                let reg = self.foo_0(39).read_async().await?;
                                
                                callback(0 + 39 * 1000, "foo_0[39]", reg.into());
                            
                                
                                let reg = self.foo_0(40).read_async().await?;
                                
                                callback(0 + 40 * 1000, "foo_0[40]", reg.into());
                            
                                
                                let reg = self.foo_0(41).read_async().await?;
                                
                                callback(0 + 41 * 1000, "foo_0[41]", reg.into());
                            
                                
                                let reg = self.foo_0(42).read_async().await?;
                                
                                callback(0 + 42 * 1000, "foo_0[42]", reg.into());
                            
                                
                                let reg = self.foo_0(43).read_async().await?;
                                
                                callback(0 + 43 * 1000, "foo_0[43]", reg.into());
                            
                                
                                let reg = self.foo_0(44).read_async().await?;
                                
                                callback(0 + 44 * 1000, "foo_0[44]", reg.into());
                            
                                
                                let reg = self.foo_0(45).read_async().await?;
                                
                                callback(0 + 45 * 1000, "foo_0[45]", reg.into());
                            
                                
                                let reg = self.foo_0(46).read_async().await?;
                                
                                callback(0 + 46 * 1000, "foo_0[46]", reg.into());
                            
                                
                                let reg = self.foo_0(47).read_async().await?;
                                
                                callback(0 + 47 * 1000, "foo_0[47]", reg.into());
                            
                                
                                let reg = self.foo_0(48).read_async().await?;
                                
                                callback(0 + 48 * 1000, "foo_0[48]", reg.into());
                            
                                
                                let reg = self.foo_0(49).read_async().await?;
                                
                                callback(0 + 49 * 1000, "foo_0[49]", reg.into());
                            
                                
                                let reg = self.foo_0(50).read_async().await?;
                                
                                callback(0 + 50 * 1000, "foo_0[50]", reg.into());
                            
                                
                                let reg = self.foo_0(51).read_async().await?;
                                
                                callback(0 + 51 * 1000, "foo_0[51]", reg.into());
                            
                                
                                let reg = self.foo_0(52).read_async().await?;
                                
                                callback(0 + 52 * 1000, "foo_0[52]", reg.into());
                            
                                
                                let reg = self.foo_0(53).read_async().await?;
                                
                                callback(0 + 53 * 1000, "foo_0[53]", reg.into());
                            
                                
                                let reg = self.foo_0(54).read_async().await?;
                                
                                callback(0 + 54 * 1000, "foo_0[54]", reg.into());
                            
                                
                                let reg = self.foo_0(55).read_async().await?;
                                
                                callback(0 + 55 * 1000, "foo_0[55]", reg.into());
                            
                                
                                let reg = self.foo_0(56).read_async().await?;
                                
                                callback(0 + 56 * 1000, "foo_0[56]", reg.into());
                            
                                
                                let reg = self.foo_0(57).read_async().await?;
                                
                                callback(0 + 57 * 1000, "foo_0[57]", reg.into());
                            
                                
                                let reg = self.foo_0(58).read_async().await?;
                                
                                callback(0 + 58 * 1000, "foo_0[58]", reg.into());
                            
                                
                                let reg = self.foo_0(59).read_async().await?;
                                
                                callback(0 + 59 * 1000, "foo_0[59]", reg.into());
                            
                                
                                let reg = self.foo_0(60).read_async().await?;
                                
                                callback(0 + 60 * 1000, "foo_0[60]", reg.into());
                            
                                
                                let reg = self.foo_0(61).read_async().await?;
                                
                                callback(0 + 61 * 1000, "foo_0[61]", reg.into());
                            
                                
                                let reg = self.foo_0(62).read_async().await?;
                                
                                callback(0 + 62 * 1000, "foo_0[62]", reg.into());
                            
                                
                                let reg = self.foo_0(63).read_async().await?;
                                
                                callback(0 + 63 * 1000, "foo_0[63]", reg.into());
                            
                                
                                let reg = self.foo_0(64).read_async().await?;
                                
                                callback(0 + 64 * 1000, "foo_0[64]", reg.into());
                            
                                
                                let reg = self.foo_0(65).read_async().await?;
                                
                                callback(0 + 65 * 1000, "foo_0[65]", reg.into());
                            
                                
                                let reg = self.foo_0(66).read_async().await?;
                                
                                callback(0 + 66 * 1000, "foo_0[66]", reg.into());
                            
                                
                                let reg = self.foo_0(67).read_async().await?;
                                
                                callback(0 + 67 * 1000, "foo_0[67]", reg.into());
                            
                                
                                let reg = self.foo_0(68).read_async().await?;
                                
                                callback(0 + 68 * 1000, "foo_0[68]", reg.into());
                            
                                
                                let reg = self.foo_0(69).read_async().await?;
                                
                                callback(0 + 69 * 1000, "foo_0[69]", reg.into());
                            
                                
                                let reg = self.foo_0(70).read_async().await?;
                                
                                callback(0 + 70 * 1000, "foo_0[70]", reg.into());
                            
                                
                                let reg = self.foo_0(71).read_async().await?;
                                
                                callback(0 + 71 * 1000, "foo_0[71]", reg.into());
                            
                                
                                let reg = self.foo_0(72).read_async().await?;
                                
                                callback(0 + 72 * 1000, "foo_0[72]", reg.into());
                            
                                
                                let reg = self.foo_0(73).read_async().await?;
                                
                                callback(0 + 73 * 1000, "foo_0[73]", reg.into());
                            
                                
                                let reg = self.foo_0(74).read_async().await?;
                                
                                callback(0 + 74 * 1000, "foo_0[74]", reg.into());
                            
                                
                                let reg = self.foo_0(75).read_async().await?;
                                
                                callback(0 + 75 * 1000, "foo_0[75]", reg.into());
                            
                                
                                let reg = self.foo_0(76).read_async().await?;
                                
                                callback(0 + 76 * 1000, "foo_0[76]", reg.into());
                            
                                
                                let reg = self.foo_0(77).read_async().await?;
                                
                                callback(0 + 77 * 1000, "foo_0[77]", reg.into());
                            
                                
                                let reg = self.foo_0(78).read_async().await?;
                                
                                callback(0 + 78 * 1000, "foo_0[78]", reg.into());
                            
                                
                                let reg = self.foo_0(79).read_async().await?;
                                
                                callback(0 + 79 * 1000, "foo_0[79]", reg.into());
                            
                                
                                let reg = self.foo_0(80).read_async().await?;
                                
                                callback(0 + 80 * 1000, "foo_0[80]", reg.into());
                            
                                
                                let reg = self.foo_0(81).read_async().await?;
                                
                                callback(0 + 81 * 1000, "foo_0[81]", reg.into());
                            
                                
                                let reg = self.foo_0(82).read_async().await?;
                                
                                callback(0 + 82 * 1000, "foo_0[82]", reg.into());
                            
                                
                                let reg = self.foo_0(83).read_async().await?;
                                
                                callback(0 + 83 * 1000, "foo_0[83]", reg.into());
                            
                                
                                let reg = self.foo_0(84).read_async().await?;
                                
                                callback(0 + 84 * 1000, "foo_0[84]", reg.into());
                            
                                
                                let reg = self.foo_0(85).read_async().await?;
                                
                                callback(0 + 85 * 1000, "foo_0[85]", reg.into());
                            
                                
                                let reg = self.foo_0(86).read_async().await?;
                                
                                callback(0 + 86 * 1000, "foo_0[86]", reg.into());
                            
                                
                                let reg = self.foo_0(87).read_async().await?;
                                
                                callback(0 + 87 * 1000, "foo_0[87]", reg.into());
                            
                                
                                let reg = self.foo_0(88).read_async().await?;
                                
                                callback(0 + 88 * 1000, "foo_0[88]", reg.into());
                            
                                
                                let reg = self.foo_0(89).read_async().await?;
                                
                                callback(0 + 89 * 1000, "foo_0[89]", reg.into());
                            
                                
                                let reg = self.foo_0(90).read_async().await?;
                                
                                callback(0 + 90 * 1000, "foo_0[90]", reg.into());
                            
                                
                                let reg = self.foo_0(91).read_async().await?;
                                
                                callback(0 + 91 * 1000, "foo_0[91]", reg.into());
                            
                                
                                let reg = self.foo_0(92).read_async().await?;
                                
                                callback(0 + 92 * 1000, "foo_0[92]", reg.into());
                            
                                
                                let reg = self.foo_0(93).read_async().await?;
                                
                                callback(0 + 93 * 1000, "foo_0[93]", reg.into());
                            
                                
                                let reg = self.foo_0(94).read_async().await?;
                                
                                callback(0 + 94 * 1000, "foo_0[94]", reg.into());
                            
                                
                                let reg = self.foo_0(95).read_async().await?;
                                
                                callback(0 + 95 * 1000, "foo_0[95]", reg.into());
                            
                                
                                let reg = self.foo_0(96).read_async().await?;
                                
                                callback(0 + 96 * 1000, "foo_0[96]", reg.into());
                            
                                
                                let reg = self.foo_0(97).read_async().await?;
                                
                                callback(0 + 97 * 1000, "foo_0[97]", reg.into());
                            
                                
                                let reg = self.foo_0(98).read_async().await?;
                                
                                callback(0 + 98 * 1000, "foo_0[98]", reg.into());
                            
                                
                                let reg = self.foo_0(99).read_async().await?;
                                
                                callback(0 + 99 * 1000, "foo_0[99]", reg.into());
                            
                        
                
            
        
            
                
                    
                            
                                
                                let reg = self.foo_1(0).read_async().await?;
                                
                                callback(1 + 0 * 1000, "foo_1[0]", reg.into());
                            
                                
                                let reg = self.foo_1(1).read_async().await?;
                                
                                callback(1 + 1 * 1000, "foo_1[1]", reg.into());
                            
                                
                                let reg = self.foo_1(2).read_async().await?;
                                
                                callback(1 + 2 * 1000, "foo_1[2]", reg.into());
                            
                                
                                let reg = self.foo_1(3).read_async().await?;
                                
                                callback(1 + 3 * 1000, "foo_1[3]", reg.into());
                            
                                
                                let reg = self.foo_1(4).read_async().await?;
                                
                                callback(1 + 4 * 1000, "foo_1[4]", reg.into());
                            
                                
                                let reg = self.foo_1(5).read_async().await?;
                                
                                callback(1 + 5 * 1000, "foo_1[5]", reg.into());
                            
                                
                                let reg = self.foo_1(6).read_async().await?;
                                
                                callback(1 + 6 * 1000, "foo_1[6]", reg.into());
                            
                                
                                let reg = self.foo_1(7).read_async().await?;
                                
                                callback(1 + 7 * 1000, "foo_1[7]", reg.into());
                            
                                
                                let reg = self.foo_1(8).read_async().await?;
                                
                                callback(1 + 8 * 1000, "foo_1[8]", reg.into());
                            
                                
                                let reg = self.foo_1(9).read_async().await?;
                                
                                callback(1 + 9 * 1000, "foo_1[9]", reg.into());
                            
                                
                                let reg = self.foo_1(10).read_async().await?;
                                
                                callback(1 + 10 * 1000, "foo_1[10]", reg.into());
                            
                                
                                let reg = self.foo_1(11).read_async().await?;
                                
                                callback(1 + 11 * 1000, "foo_1[11]", reg.into());
                            
                                
                                let reg = self.foo_1(12).read_async().await?;
                                
                                callback(1 + 12 * 1000, "foo_1[12]", reg.into());
                            
                                
                                let reg = self.foo_1(13).read_async().await?;
                                
                                callback(1 + 13 * 1000, "foo_1[13]", reg.into());
                            
                                
                                let reg = self.foo_1(14).read_async().await?;
                                
                                callback(1 + 14 * 1000, "foo_1[14]", reg.into());
                            
                                
                                let reg = self.foo_1(15).read_async().await?;
                                
                                callback(1 + 15 * 1000, "foo_1[15]", reg.into());
                            
                                
                                let reg = self.foo_1(16).read_async().await?;
                                
                                callback(1 + 16 * 1000, "foo_1[16]", reg.into());
                            
                                
                                let reg = self.foo_1(17).read_async().await?;
                                
                                callback(1 + 17 * 1000, "foo_1[17]", reg.into());
                            
                                
                                let reg = self.foo_1(18).read_async().await?;
                                
                                callback(1 + 18 * 1000, "foo_1[18]", reg.into());
                            
                                
                                let reg = self.foo_1(19).read_async().await?;
                                
                                callback(1 + 19 * 1000, "foo_1[19]", reg.into());
                            
                                
                                let reg = self.foo_1(20).read_async().await?;
                                
                                callback(1 + 20 * 1000, "foo_1[20]", reg.into());
                            
                                
                                let reg = self.foo_1(21).read_async().await?;
                                
                                callback(1 + 21 * 1000, "foo_1[21]", reg.into());
                            
                                
                                let reg = self.foo_1(22).read_async().await?;
                                
                                callback(1 + 22 * 1000, "foo_1[22]", reg.into());
                            
                                
                                let reg = self.foo_1(23).read_async().await?;
                                
                                callback(1 + 23 * 1000, "foo_1[23]", reg.into());
                            
                                
                                let reg = self.foo_1(24).read_async().await?;
                                
                                callback(1 + 24 * 1000, "foo_1[24]", reg.into());
                            
                                
                                let reg = self.foo_1(25).read_async().await?;
                                
                                callback(1 + 25 * 1000, "foo_1[25]", reg.into());
                            
                                
                                let reg = self.foo_1(26).read_async().await?;
                                
                                callback(1 + 26 * 1000, "foo_1[26]", reg.into());
                            
                                
                                let reg = self.foo_1(27).read_async().await?;
                                
                                callback(1 + 27 * 1000, "foo_1[27]", reg.into());
                            
                                
                                let reg = self.foo_1(28).read_async().await?;
                                
                                callback(1 + 28 * 1000, "foo_1[28]", reg.into());
                            
                                
                                let reg = self.foo_1(29).read_async().await?;
                                
                                callback(1 + 29 * 1000, "foo_1[29]", reg.into());
                            
                                
                                let reg = self.foo_1(30).read_async().await?;
                                
                                callback(1 + 30 * 1000, "foo_1[30]", reg.into());
                            
                                
                                let reg = self.foo_1(31).read_async().await?;
                                
                                callback(1 + 31 * 1000, "foo_1[31]", reg.into());
                            
                                
                                let reg = self.foo_1(32).read_async().await?;
                                
                                callback(1 + 32 * 1000, "foo_1[32]", reg.into());
                            
                                
                                let reg = self.foo_1(33).read_async().await?;
                                
                                callback(1 + 33 * 1000, "foo_1[33]", reg.into());
                            
                                
                                let reg = self.foo_1(34).read_async().await?;
                                
                                callback(1 + 34 * 1000, "foo_1[34]", reg.into());
                            
                                
                                let reg = self.foo_1(35).read_async().await?;
                                
                                callback(1 + 35 * 1000, "foo_1[35]", reg.into());
                            
                                
                                let reg = self.foo_1(36).read_async().await?;
                                
                                callback(1 + 36 * 1000, "foo_1[36]", reg.into());
                            
                                
                                let reg = self.foo_1(37).read_async().await?;
                                
                                callback(1 + 37 * 1000, "foo_1[37]", reg.into());
                            
                                
                                let reg = self.foo_1(38).read_async().await?;
                                
                                callback(1 + 38 * 1000, "foo_1[38]", reg.into());
                            
                                
                                let reg = self.foo_1(39).read_async().await?;
                                
                                callback(1 + 39 * 1000, "foo_1[39]", reg.into());
                            
                                
                                let reg = self.foo_1(40).read_async().await?;
                                
                                callback(1 + 40 * 1000, "foo_1[40]", reg.into());
                            
                                
                                let reg = self.foo_1(41).read_async().await?;
                                
                                callback(1 + 41 * 1000, "foo_1[41]", reg.into());
                            
                                
                                let reg = self.foo_1(42).read_async().await?;
                                
                                callback(1 + 42 * 1000, "foo_1[42]", reg.into());
                            
                                
                                let reg = self.foo_1(43).read_async().await?;
                                
                                callback(1 + 43 * 1000, "foo_1[43]", reg.into());
                            
                                
                                let reg = self.foo_1(44).read_async().await?;
                                
                                callback(1 + 44 * 1000, "foo_1[44]", reg.into());
                            
                                
                                let reg = self.foo_1(45).read_async().await?;
                                
                                callback(1 + 45 * 1000, "foo_1[45]", reg.into());
                            
                                
                                let reg = self.foo_1(46).read_async().await?;
                                
                                callback(1 + 46 * 1000, "foo_1[46]", reg.into());
                            
                                
                                let reg = self.foo_1(47).read_async().await?;
                                
                                callback(1 + 47 * 1000, "foo_1[47]", reg.into());
                            
                                
                                let reg = self.foo_1(48).read_async().await?;
                                
                                callback(1 + 48 * 1000, "foo_1[48]", reg.into());
                            
                                
                                let reg = self.foo_1(49).read_async().await?;
                                
                                callback(1 + 49 * 1000, "foo_1[49]", reg.into());
                            
                                
                                let reg = self.foo_1(50).read_async().await?;
                                
                                callback(1 + 50 * 1000, "foo_1[50]", reg.into());
                            
                                
                                let reg = self.foo_1(51).read_async().await?;
                                
                                callback(1 + 51 * 1000, "foo_1[51]", reg.into());
                            
                                
                                let reg = self.foo_1(52).read_async().await?;
                                
                                callback(1 + 52 * 1000, "foo_1[52]", reg.into());
                            
                                
                                let reg = self.foo_1(53).read_async().await?;
                                
                                callback(1 + 53 * 1000, "foo_1[53]", reg.into());
                            
                                
                                let reg = self.foo_1(54).read_async().await?;
                                
                                callback(1 + 54 * 1000, "foo_1[54]", reg.into());
                            
                                
                                let reg = self.foo_1(55).read_async().await?;
                                
                                callback(1 + 55 * 1000, "foo_1[55]", reg.into());
                            
                                
                                let reg = self.foo_1(56).read_async().await?;
                                
                                callback(1 + 56 * 1000, "foo_1[56]", reg.into());
                            
                                
                                let reg = self.foo_1(57).read_async().await?;
                                
                                callback(1 + 57 * 1000, "foo_1[57]", reg.into());
                            
                                
                                let reg = self.foo_1(58).read_async().await?;
                                
                                callback(1 + 58 * 1000, "foo_1[58]", reg.into());
                            
                                
                                let reg = self.foo_1(59).read_async().await?;
                                
                                callback(1 + 59 * 1000, "foo_1[59]", reg.into());
                            
                                
                                let reg = self.foo_1(60).read_async().await?;
                                
                                callback(1 + 60 * 1000, "foo_1[60]", reg.into());
                            
                                
                                let reg = self.foo_1(61).read_async().await?;
                                
                                callback(1 + 61 * 1000, "foo_1[61]", reg.into());
                            
                                
                                let reg = self.foo_1(62).read_async().await?;
                                
                                callback(1 + 62 * 1000, "foo_1[62]", reg.into());
                            
                                
                                let reg = self.foo_1(63).read_async().await?;
                                
                                callback(1 + 63 * 1000, "foo_1[63]", reg.into());
                            
                                
                                let reg = self.foo_1(64).read_async().await?;
                                
                                callback(1 + 64 * 1000, "foo_1[64]", reg.into());
                            
                                
                                let reg = self.foo_1(65).read_async().await?;
                                
                                callback(1 + 65 * 1000, "foo_1[65]", reg.into());
                            
                                
                                let reg = self.foo_1(66).read_async().await?;
                                
                                callback(1 + 66 * 1000, "foo_1[66]", reg.into());
                            
                                
                                let reg = self.foo_1(67).read_async().await?;
                                
                                callback(1 + 67 * 1000, "foo_1[67]", reg.into());
                            
                                
                                let reg = self.foo_1(68).read_async().await?;
                                
                                callback(1 + 68 * 1000, "foo_1[68]", reg.into());
                            
                                
                                let reg = self.foo_1(69).read_async().await?;
                                
                                callback(1 + 69 * 1000, "foo_1[69]", reg.into());
                            
                                
                                let reg = self.foo_1(70).read_async().await?;
                                
                                callback(1 + 70 * 1000, "foo_1[70]", reg.into());
                            
                                
                                let reg = self.foo_1(71).read_async().await?;
                                
                                callback(1 + 71 * 1000, "foo_1[71]", reg.into());
                            
                                
                                let reg = self.foo_1(72).read_async().await?;
                                
                                callback(1 + 72 * 1000, "foo_1[72]", reg.into());
                            
                                
                                let reg = self.foo_1(73).read_async().await?;
                                
                                callback(1 + 73 * 1000, "foo_1[73]", reg.into());
                            
                                
                                let reg = self.foo_1(74).read_async().await?;
                                
                                callback(1 + 74 * 1000, "foo_1[74]", reg.into());
                            
                                
                                let reg = self.foo_1(75).read_async().await?;
                                
                                callback(1 + 75 * 1000, "foo_1[75]", reg.into());
                            
                                
                                let reg = self.foo_1(76).read_async().await?;
                                
                                callback(1 + 76 * 1000, "foo_1[76]", reg.into());
                            
                                
                                let reg = self.foo_1(77).read_async().await?;
                                
                                callback(1 + 77 * 1000, "foo_1[77]", reg.into());
                            
                                
                                let reg = self.foo_1(78).read_async().await?;
                                
                                callback(1 + 78 * 1000, "foo_1[78]", reg.into());
                            
                                
                                let reg = self.foo_1(79).read_async().await?;
                                
                                callback(1 + 79 * 1000, "foo_1[79]", reg.into());
                            
                                
                                let reg = self.foo_1(80).read_async().await?;
                                
                                callback(1 + 80 * 1000, "foo_1[80]", reg.into());
                            
                                
                                let reg = self.foo_1(81).read_async().await?;
                                
                                callback(1 + 81 * 1000, "foo_1[81]", reg.into());
                            
                                
                                let reg = self.foo_1(82).read_async().await?;
                                
                                callback(1 + 82 * 1000, "foo_1[82]", reg.into());
                            
                                
                                let reg = self.foo_1(83).read_async().await?;
                                
                                callback(1 + 83 * 1000, "foo_1[83]", reg.into());
                            
                                
                                let reg = self.foo_1(84).read_async().await?;
                                
                                callback(1 + 84 * 1000, "foo_1[84]", reg.into());
                            
                                
                                let reg = self.foo_1(85).read_async().await?;
                                
                                callback(1 + 85 * 1000, "foo_1[85]", reg.into());
                            
                                
                                let reg = self.foo_1(86).read_async().await?;
                                
                                callback(1 + 86 * 1000, "foo_1[86]", reg.into());
                            
                                
                                let reg = self.foo_1(87).read_async().await?;
                                
                                callback(1 + 87 * 1000, "foo_1[87]", reg.into());
                            
                                
                                let reg = self.foo_1(88).read_async().await?;
                                
                                callback(1 + 88 * 1000, "foo_1[88]", reg.into());
                            
                                
                                let reg = self.foo_1(89).read_async().await?;
                                
                                callback(1 + 89 * 1000, "foo_1[89]", reg.into());
                            
                                
                                let reg = self.foo_1(90).read_async().await?;
                                
                                callback(1 + 90 * 1000, "foo_1[90]", reg.into());
                            
                                
                                let reg = self.foo_1(91).read_async().await?;
                                
                                callback(1 + 91 * 1000, "foo_1[91]", reg.into());
                            
                                
                                let reg = self.foo_1(92).read_async().await?;
                                
                                callback(1 + 92 * 1000, "foo_1[92]", reg.into());
                            
                                
                                let reg = self.foo_1(93).read_async().await?;
                                
                                callback(1 + 93 * 1000, "foo_1[93]", reg.into());
                            
                                
                                let reg = self.foo_1(94).read_async().await?;
                                
                                callback(1 + 94 * 1000, "foo_1[94]", reg.into());
                            
                                
                                let reg = self.foo_1(95).read_async().await?;
                                
                                callback(1 + 95 * 1000, "foo_1[95]", reg.into());
                            
                                
                                let reg = self.foo_1(96).read_async().await?;
                                
                                callback(1 + 96 * 1000, "foo_1[96]", reg.into());
                            
                                
                                let reg = self.foo_1(97).read_async().await?;
                                
                                callback(1 + 97 * 1000, "foo_1[97]", reg.into());
                            
                                
                                let reg = self.foo_1(98).read_async().await?;
                                
                                callback(1 + 98 * 1000, "foo_1[98]", reg.into());
                            
                                
                                let reg = self.foo_1(99).read_async().await?;
                                
                                callback(1 + 99 * 1000, "foo_1[99]", reg.into());
                            
                        
                
            
        
            
                
                    
                            
                                
                                let reg = self.foo_2(0).read_async().await?;
                                
                                callback(2 + 0 * 1000, "foo_2[0]", reg.into());
                            
                                
                                let reg = self.foo_2(1).read_async().await?;
                                
                                callback(2 + 1 * 1000, "foo_2[1]", reg.into());
                            
                                
                                let reg = self.foo_2(2).read_async().await?;
                                
                                callback(2 + 2 * 1000, "foo_2[2]", reg.into());
                            
                                
                                let reg = self.foo_2(3).read_async().await?;
                                
                                callback(2 + 3 * 1000, "foo_2[3]", reg.into());
                            
                                
                                let reg = self.foo_2(4).read_async().await?;
                                
                                callback(2 + 4 * 1000, "foo_2[4]", reg.into());
                            
                                
                                let reg = self.foo_2(5).read_async().await?;
                                
                                callback(2 + 5 * 1000, "foo_2[5]", reg.into());
                            
                                
                                let reg = self.foo_2(6).read_async().await?;
                                
                                callback(2 + 6 * 1000, "foo_2[6]", reg.into());
                            
                                
                                let reg = self.foo_2(7).read_async().await?;
                                
                                callback(2 + 7 * 1000, "foo_2[7]", reg.into());
                            
                                
                                let reg = self.foo_2(8).read_async().await?;
                                
                                callback(2 + 8 * 1000, "foo_2[8]", reg.into());
                            
                                
                                let reg = self.foo_2(9).read_async().await?;
                                
                                callback(2 + 9 * 1000, "foo_2[9]", reg.into());
                            
                                
                                let reg = self.foo_2(10).read_async().await?;
                                
                                callback(2 + 10 * 1000, "foo_2[10]", reg.into());
                            
                                
                                let reg = self.foo_2(11).read_async().await?;
                                
                                callback(2 + 11 * 1000, "foo_2[11]", reg.into());
                            
                                
                                let reg = self.foo_2(12).read_async().await?;
                                
                                callback(2 + 12 * 1000, "foo_2[12]", reg.into());
                            
                                
                                let reg = self.foo_2(13).read_async().await?;
                                
                                callback(2 + 13 * 1000, "foo_2[13]", reg.into());
                            
                                
                                let reg = self.foo_2(14).read_async().await?;
                                
                                callback(2 + 14 * 1000, "foo_2[14]", reg.into());
                            
                                
                                let reg = self.foo_2(15).read_async().await?;
                                
                                callback(2 + 15 * 1000, "foo_2[15]", reg.into());
                            
                                
                                let reg = self.foo_2(16).read_async().await?;
                                
                                callback(2 + 16 * 1000, "foo_2[16]", reg.into());
                            
                                
                                let reg = self.foo_2(17).read_async().await?;
                                
                                callback(2 + 17 * 1000, "foo_2[17]", reg.into());
                            
                                
                                let reg = self.foo_2(18).read_async().await?;
                                
                                callback(2 + 18 * 1000, "foo_2[18]", reg.into());
                            
                                
                                let reg = self.foo_2(19).read_async().await?;
                                
                                callback(2 + 19 * 1000, "foo_2[19]", reg.into());
                            
                                
                                let reg = self.foo_2(20).read_async().await?;
                                
                                callback(2 + 20 * 1000, "foo_2[20]", reg.into());
                            
                                
                                let reg = self.foo_2(21).read_async().await?;
                                
                                callback(2 + 21 * 1000, "foo_2[21]", reg.into());
                            
                                
                                let reg = self.foo_2(22).read_async().await?;
                                
                                callback(2 + 22 * 1000, "foo_2[22]", reg.into());
                            
                                
                                let reg = self.foo_2(23).read_async().await?;
                                
                                callback(2 + 23 * 1000, "foo_2[23]", reg.into());
                            
                                
                                let reg = self.foo_2(24).read_async().await?;
                                
                                callback(2 + 24 * 1000, "foo_2[24]", reg.into());
                            
                                
                                let reg = self.foo_2(25).read_async().await?;
                                
                                callback(2 + 25 * 1000, "foo_2[25]", reg.into());
                            
                                
                                let reg = self.foo_2(26).read_async().await?;
                                
                                callback(2 + 26 * 1000, "foo_2[26]", reg.into());
                            
                                
                                let reg = self.foo_2(27).read_async().await?;
                                
                                callback(2 + 27 * 1000, "foo_2[27]", reg.into());
                            
                                
                                let reg = self.foo_2(28).read_async().await?;
                                
                                callback(2 + 28 * 1000, "foo_2[28]", reg.into());
                            
                                
                                let reg = self.foo_2(29).read_async().await?;
                                
                                callback(2 + 29 * 1000, "foo_2[29]", reg.into());
                            
                                
                                let reg = self.foo_2(30).read_async().await?;
                                
                                callback(2 + 30 * 1000, "foo_2[30]", reg.into());
                            
                                
                                let reg = self.foo_2(31).read_async().await?;
                                
                                callback(2 + 31 * 1000, "foo_2[31]", reg.into());
                            
                                
                                let reg = self.foo_2(32).read_async().await?;
                                
                                callback(2 + 32 * 1000, "foo_2[32]", reg.into());
                            
                                
                                let reg = self.foo_2(33).read_async().await?;
                                
                                callback(2 + 33 * 1000, "foo_2[33]", reg.into());
                            
                                
                                let reg = self.foo_2(34).read_async().await?;
                                
                                callback(2 + 34 * 1000, "foo_2[34]", reg.into());
                            
                                
                                let reg = self.foo_2(35).read_async().await?;
                                
                                callback(2 + 35 * 1000, "foo_2[35]", reg.into());
                            
                                
                                let reg = self.foo_2(36).read_async().await?;
                                
                                callback(2 + 36 * 1000, "foo_2[36]", reg.into());
                            
                                
                                let reg = self.foo_2(37).read_async().await?;
                                
                                callback(2 + 37 * 1000, "foo_2[37]", reg.into());
                            
                                
                                let reg = self.foo_2(38).read_async().await?;
                                
                                callback(2 + 38 * 1000, "foo_2[38]", reg.into());
                            
                                
                                let reg = self.foo_2(39).read_async().await?;
                                
                                callback(2 + 39 * 1000, "foo_2[39]", reg.into());
                            
                                
                                let reg = self.foo_2(40).read_async().await?;
                                
                                callback(2 + 40 * 1000, "foo_2[40]", reg.into());
                            
                                
                                let reg = self.foo_2(41).read_async().await?;
                                
                                callback(2 + 41 * 1000, "foo_2[41]", reg.into());
                            
                                
                                let reg = self.foo_2(42).read_async().await?;
                                
                                callback(2 + 42 * 1000, "foo_2[42]", reg.into());
                            
                                
                                let reg = self.foo_2(43).read_async().await?;
                                
                                callback(2 + 43 * 1000, "foo_2[43]", reg.into());
                            
                                
                                let reg = self.foo_2(44).read_async().await?;
                                
                                callback(2 + 44 * 1000, "foo_2[44]", reg.into());
                            
                                
                                let reg = self.foo_2(45).read_async().await?;
                                
                                callback(2 + 45 * 1000, "foo_2[45]", reg.into());
                            
                                
                                let reg = self.foo_2(46).read_async().await?;
                                
                                callback(2 + 46 * 1000, "foo_2[46]", reg.into());
                            
                                
                                let reg = self.foo_2(47).read_async().await?;
                                
                                callback(2 + 47 * 1000, "foo_2[47]", reg.into());
                            
                                
                                let reg = self.foo_2(48).read_async().await?;
                                
                                callback(2 + 48 * 1000, "foo_2[48]", reg.into());
                            
                                
                                let reg = self.foo_2(49).read_async().await?;
                                
                                callback(2 + 49 * 1000, "foo_2[49]", reg.into());
                            
                                
                                let reg = self.foo_2(50).read_async().await?;
                                
                                callback(2 + 50 * 1000, "foo_2[50]", reg.into());
                            
                                
                                let reg = self.foo_2(51).read_async().await?;
                                
                                callback(2 + 51 * 1000, "foo_2[51]", reg.into());
                            
                                
                                let reg = self.foo_2(52).read_async().await?;
                                
                                callback(2 + 52 * 1000, "foo_2[52]", reg.into());
                            
                                
                                let reg = self.foo_2(53).read_async().await?;
                                
                                callback(2 + 53 * 1000, "foo_2[53]", reg.into());
                            
                                
                                let reg = self.foo_2(54).read_async().await?;
                                
                                callback(2 + 54 * 1000, "foo_2[54]", reg.into());
                            
                                
                                let reg = self.foo_2(55).read_async().await?;
                                
                                callback(2 + 55 * 1000, "foo_2[55]", reg.into());
                            
                                
                                let reg = self.foo_2(56).read_async().await?;
                                
                                callback(2 + 56 * 1000, "foo_2[56]", reg.into());
                            
                                
                                let reg = self.foo_2(57).read_async().await?;
                                
                                callback(2 + 57 * 1000, "foo_2[57]", reg.into());
                            
                                
                                let reg = self.foo_2(58).read_async().await?;
                                
                                callback(2 + 58 * 1000, "foo_2[58]", reg.into());
                            
                                
                                let reg = self.foo_2(59).read_async().await?;
                                
                                callback(2 + 59 * 1000, "foo_2[59]", reg.into());
                            
                                
                                let reg = self.foo_2(60).read_async().await?;
                                
                                callback(2 + 60 * 1000, "foo_2[60]", reg.into());
                            
                                
                                let reg = self.foo_2(61).read_async().await?;
                                
                                callback(2 + 61 * 1000, "foo_2[61]", reg.into());
                            
                                
                                let reg = self.foo_2(62).read_async().await?;
                                
                                callback(2 + 62 * 1000, "foo_2[62]", reg.into());
                            
                                
                                let reg = self.foo_2(63).read_async().await?;
                                
                                callback(2 + 63 * 1000, "foo_2[63]", reg.into());
                            
                                
                                let reg = self.foo_2(64).read_async().await?;
                                
                                callback(2 + 64 * 1000, "foo_2[64]", reg.into());
                            
                                
                                let reg = self.foo_2(65).read_async().await?;
                                
                                callback(2 + 65 * 1000, "foo_2[65]", reg.into());
                            
                                
                                let reg = self.foo_2(66).read_async().await?;
                                
                                callback(2 + 66 * 1000, "foo_2[66]", reg.into());
                            
                                
                                let reg = self.foo_2(67).read_async().await?;
                                
                                callback(2 + 67 * 1000, "foo_2[67]", reg.into());
                            
                                
                                let reg = self.foo_2(68).read_async().await?;
                                
                                callback(2 + 68 * 1000, "foo_2[68]", reg.into());
                            
                                
                                let reg = self.foo_2(69).read_async().await?;
                                
                                callback(2 + 69 * 1000, "foo_2[69]", reg.into());
                            
                                
                                let reg = self.foo_2(70).read_async().await?;
                                
                                callback(2 + 70 * 1000, "foo_2[70]", reg.into());
                            
                                
                                let reg = self.foo_2(71).read_async().await?;
                                
                                callback(2 + 71 * 1000, "foo_2[71]", reg.into());
                            
                                
                                let reg = self.foo_2(72).read_async().await?;
                                
                                callback(2 + 72 * 1000, "foo_2[72]", reg.into());
                            
                                
                                let reg = self.foo_2(73).read_async().await?;
                                
                                callback(2 + 73 * 1000, "foo_2[73]", reg.into());
                            
                                
                                let reg = self.foo_2(74).read_async().await?;
                                
                                callback(2 + 74 * 1000, "foo_2[74]", reg.into());
                            
                                
                                let reg = self.foo_2(75).read_async().await?;
                                
                                callback(2 + 75 * 1000, "foo_2[75]", reg.into());
                            
                                
                                let reg = self.foo_2(76).read_async().await?;
                                
                                callback(2 + 76 * 1000, "foo_2[76]", reg.into());
                            
                                
                                let reg = self.foo_2(77).read_async().await?;
                                
                                callback(2 + 77 * 1000, "foo_2[77]", reg.into());
                            
                                
                                let reg = self.foo_2(78).read_async().await?;
                                
                                callback(2 + 78 * 1000, "foo_2[78]", reg.into());
                            
                                
                                let reg = self.foo_2(79).read_async().await?;
                                
                                callback(2 + 79 * 1000, "foo_2[79]", reg.into());
                            
                                
                                let reg = self.foo_2(80).read_async().await?;
                                
                                callback(2 + 80 * 1000, "foo_2[80]", reg.into());
                            
                                
                                let reg = self.foo_2(81).read_async().await?;
                                
                                callback(2 + 81 * 1000, "foo_2[81]", reg.into());
                            
                                
                                let reg = self.foo_2(82).read_async().await?;
                                
                                callback(2 + 82 * 1000, "foo_2[82]", reg.into());
                            
                                
                                let reg = self.foo_2(83).read_async().await?;
                                
                                callback(2 + 83 * 1000, "foo_2[83]", reg.into());
                            
                                
                                let reg = self.foo_2(84).read_async().await?;
                                
                                callback(2 + 84 * 1000, "foo_2[84]", reg.into());
                            
                                
                                let reg = self.foo_2(85).read_async().await?;
                                
                                callback(2 + 85 * 1000, "foo_2[85]", reg.into());
                            
                                
                                let reg = self.foo_2(86).read_async().await?;
                                
                                callback(2 + 86 * 1000, "foo_2[86]", reg.into());
                            
                                
                                let reg = self.foo_2(87).read_async().await?;
                                
                                callback(2 + 87 * 1000, "foo_2[87]", reg.into());
                            
                                
                                let reg = self.foo_2(88).read_async().await?;
                                
                                callback(2 + 88 * 1000, "foo_2[88]", reg.into());
                            
                                
                                let reg = self.foo_2(89).read_async().await?;
                                
                                callback(2 + 89 * 1000, "foo_2[89]", reg.into());
                            
                                
                                let reg = self.foo_2(90).read_async().await?;
                                
                                callback(2 + 90 * 1000, "foo_2[90]", reg.into());
                            
                                
                                let reg = self.foo_2(91).read_async().await?;
                                
                                callback(2 + 91 * 1000, "foo_2[91]", reg.into());
                            
                                
                                let reg = self.foo_2(92).read_async().await?;
                                
                                callback(2 + 92 * 1000, "foo_2[92]", reg.into());
                            
                                
                                let reg = self.foo_2(93).read_async().await?;
                                
                                callback(2 + 93 * 1000, "foo_2[93]", reg.into());
                            
                                
                                let reg = self.foo_2(94).read_async().await?;
                                
                                callback(2 + 94 * 1000, "foo_2[94]", reg.into());
                            
                                
                                let reg = self.foo_2(95).read_async().await?;
                                
                                callback(2 + 95 * 1000, "foo_2[95]", reg.into());
                            
                                
                                let reg = self.foo_2(96).read_async().await?;
                                
                                callback(2 + 96 * 1000, "foo_2[96]", reg.into());
                            
                                
                                let reg = self.foo_2(97).read_async().await?;
                                
                                callback(2 + 97 * 1000, "foo_2[97]", reg.into());
                            
                                
                                let reg = self.foo_2(98).read_async().await?;
                                
                                callback(2 + 98 * 1000, "foo_2[98]", reg.into());
                            
                                
                                let reg = self.foo_2(99).read_async().await?;
                                
                                callback(2 + 99 * 1000, "foo_2[99]", reg.into());
                            
                        
                
            
        
            
                
                    
                            
                                
                                let reg = self.foo_3(0).read_async().await?;
                                
                                callback(3 + 0 * 1000, "foo_3[0]", reg.into());
                            
                                
                                let reg = self.foo_3(1).read_async().await?;
                                
                                callback(3 + 1 * 1000, "foo_3[1]", reg.into());
                            
                                
                                let reg = self.foo_3(2).read_async().await?;
                                
                                callback(3 + 2 * 1000, "foo_3[2]", reg.into());
                            
                                
                                let reg = self.foo_3(3).read_async().await?;
                                
                                callback(3 + 3 * 1000, "foo_3[3]", reg.into());
                            
                                
                                let reg = self.foo_3(4).read_async().await?;
                                
                                callback(3 + 4 * 1000, "foo_3[4]", reg.into());
                            
                                
                                let reg = self.foo_3(5).read_async().await?;
                                
                                callback(3 + 5 * 1000, "foo_3[5]", reg.into());
                            
                                
                                let reg = self.foo_3(6).read_async().await?;
                                
                                callback(3 + 6 * 1000, "foo_3[6]", reg.into());
                            
                                
                                let reg = self.foo_3(7).read_async().await?;
                                
                                callback(3 + 7 * 1000, "foo_3[7]", reg.into());
                            
                                
                                let reg = self.foo_3(8).read_async().await?;
                                
                                callback(3 + 8 * 1000, "foo_3[8]", reg.into());
                            
                                
                                let reg = self.foo_3(9).read_async().await?;
                                
                                callback(3 + 9 * 1000, "foo_3[9]", reg.into());
                            
                                
                                let reg = self.foo_3(10).read_async().await?;
                                
                                callback(3 + 10 * 1000, "foo_3[10]", reg.into());
                            
                                
                                let reg = self.foo_3(11).read_async().await?;
                                
                                callback(3 + 11 * 1000, "foo_3[11]", reg.into());
                            
                                
                                let reg = self.foo_3(12).read_async().await?;
                                
                                callback(3 + 12 * 1000, "foo_3[12]", reg.into());
                            
                                
                                let reg = self.foo_3(13).read_async().await?;
                                
                                callback(3 + 13 * 1000, "foo_3[13]", reg.into());
                            
                                
                                let reg = self.foo_3(14).read_async().await?;
                                
                                callback(3 + 14 * 1000, "foo_3[14]", reg.into());
                            
                                
                                let reg = self.foo_3(15).read_async().await?;
                                
                                callback(3 + 15 * 1000, "foo_3[15]", reg.into());
                            
                                
                                let reg = self.foo_3(16).read_async().await?;
                                
                                callback(3 + 16 * 1000, "foo_3[16]", reg.into());
                            
                                
                                let reg = self.foo_3(17).read_async().await?;
                                
                                callback(3 + 17 * 1000, "foo_3[17]", reg.into());
                            
                                
                                let reg = self.foo_3(18).read_async().await?;
                                
                                callback(3 + 18 * 1000, "foo_3[18]", reg.into());
                            
                                
                                let reg = self.foo_3(19).read_async().await?;
                                
                                callback(3 + 19 * 1000, "foo_3[19]", reg.into());
                            
                                
                                let reg = self.foo_3(20).read_async().await?;
                                
                                callback(3 + 20 * 1000, "foo_3[20]", reg.into());
                            
                                
                                let reg = self.foo_3(21).read_async().await?;
                                
                                callback(3 + 21 * 1000, "foo_3[21]", reg.into());
                            
                                
                                let reg = self.foo_3(22).read_async().await?;
                                
                                callback(3 + 22 * 1000, "foo_3[22]", reg.into());
                            
                                
                                let reg = self.foo_3(23).read_async().await?;
                                
                                callback(3 + 23 * 1000, "foo_3[23]", reg.into());
                            
                                
                                let reg = self.foo_3(24).read_async().await?;
                                
                                callback(3 + 24 * 1000, "foo_3[24]", reg.into());
                            
                                
                                let reg = self.foo_3(25).read_async().await?;
                                
                                callback(3 + 25 * 1000, "foo_3[25]", reg.into());
                            
                                
                                let reg = self.foo_3(26).read_async().await?;
                                
                                callback(3 + 26 * 1000, "foo_3[26]", reg.into());
                            
                                
                                let reg = self.foo_3(27).read_async().await?;
                                
                                callback(3 + 27 * 1000, "foo_3[27]", reg.into());
                            
                                
                                let reg = self.foo_3(28).read_async().await?;
                                
                                callback(3 + 28 * 1000, "foo_3[28]", reg.into());
                            
                                
                                let reg = self.foo_3(29).read_async().await?;
                                
                                callback(3 + 29 * 1000, "foo_3[29]", reg.into());
                            
                                
                                let reg = self.foo_3(30).read_async().await?;
                                
                                callback(3 + 30 * 1000, "foo_3[30]", reg.into());
                            
                                
                                let reg = self.foo_3(31).read_async().await?;
                                
                                callback(3 + 31 * 1000, "foo_3[31]", reg.into());
                            
                                
                                let reg = self.foo_3(32).read_async().await?;
                                
                                callback(3 + 32 * 1000, "foo_3[32]", reg.into());
                            
                                
                                let reg = self.foo_3(33).read_async().await?;
                                
                                callback(3 + 33 * 1000, "foo_3[33]", reg.into());
                            
                                
                                let reg = self.foo_3(34).read_async().await?;
                                
                                callback(3 + 34 * 1000, "foo_3[34]", reg.into());
                            
                                
                                let reg = self.foo_3(35).read_async().await?;
                                
                                callback(3 + 35 * 1000, "foo_3[35]", reg.into());
                            
                                
                                let reg = self.foo_3(36).read_async().await?;
                                
                                callback(3 + 36 * 1000, "foo_3[36]", reg.into());
                            
                                
                                let reg = self.foo_3(37).read_async().await?;
                                
                                callback(3 + 37 * 1000, "foo_3[37]", reg.into());
                            
                                
                                let reg = self.foo_3(38).read_async().await?;
                                
                                callback(3 + 38 * 1000, "foo_3[38]", reg.into());
                            
                                
                                let reg = self.foo_3(39).read_async().await?;
                                
                                callback(3 + 39 * 1000, "foo_3[39]", reg.into());
                            
                                
                                let reg = self.foo_3(40).read_async().await?;
                                
                                callback(3 + 40 * 1000, "foo_3[40]", reg.into());
                            
                                
                                let reg = self.foo_3(41).read_async().await?;
                                
                                callback(3 + 41 * 1000, "foo_3[41]", reg.into());
                            
                                
                                let reg = self.foo_3(42).read_async().await?;
                                
                                callback(3 + 42 * 1000, "foo_3[42]", reg.into());
                            
                                
                                let reg = self.foo_3(43).read_async().await?;
                                
                                callback(3 + 43 * 1000, "foo_3[43]", reg.into());
                            
                                
                                let reg = self.foo_3(44).read_async().await?;
                                
                                callback(3 + 44 * 1000, "foo_3[44]", reg.into());
                            
                                
                                let reg = self.foo_3(45).read_async().await?;
                                
                                callback(3 + 45 * 1000, "foo_3[45]", reg.into());
                            
                                
                                let reg = self.foo_3(46).read_async().await?;
                                
                                callback(3 + 46 * 1000, "foo_3[46]", reg.into());
                            
                                
                                let reg = self.foo_3(47).read_async().await?;
                                
                                callback(3 + 47 * 1000, "foo_3[47]", reg.into());
                            
                                
                                let reg = self.foo_3(48).read_async().await?;
                                
                                callback(3 + 48 * 1000, "foo_3[48]", reg.into());
                            
                                
                                let reg = self.foo_3(49).read_async().await?;
                                
                                callback(3 + 49 * 1000, "foo_3[49]", reg.into());
                            
                                
                                let reg = self.foo_3(50).read_async().await?;
                                
                                callback(3 + 50 * 1000, "foo_3[50]", reg.into());
                            
                                
                                let reg = self.foo_3(51).read_async().await?;
                                
                                callback(3 + 51 * 1000, "foo_3[51]", reg.into());
                            
                                
                                let reg = self.foo_3(52).read_async().await?;
                                
                                callback(3 + 52 * 1000, "foo_3[52]", reg.into());
                            
                                
                                let reg = self.foo_3(53).read_async().await?;
                                
                                callback(3 + 53 * 1000, "foo_3[53]", reg.into());
                            
                                
                                let reg = self.foo_3(54).read_async().await?;
                                
                                callback(3 + 54 * 1000, "foo_3[54]", reg.into());
                            
                                
                                let reg = self.foo_3(55).read_async().await?;
                                
                                callback(3 + 55 * 1000, "foo_3[55]", reg.into());
                            
                                
                                let reg = self.foo_3(56).read_async().await?;
                                
                                callback(3 + 56 * 1000, "foo_3[56]", reg.into());
                            
                                
                                let reg = self.foo_3(57).read_async().await?;
                                
                                callback(3 + 57 * 1000, "foo_3[57]", reg.into());
                            
                                
                                let reg = self.foo_3(58).read_async().await?;
                                
                                callback(3 + 58 * 1000, "foo_3[58]", reg.into());
                            
                                
                                let reg = self.foo_3(59).read_async().await?;
                                
                                callback(3 + 59 * 1000, "foo_3[59]", reg.into());
                            
                                
                                let reg = self.foo_3(60).read_async().await?;
                                
                                callback(3 + 60 * 1000, "foo_3[60]", reg.into());
                            
                                
                                let reg = self.foo_3(61).read_async().await?;
                                
                                callback(3 + 61 * 1000, "foo_3[61]", reg.into());
                            
                                
                                let reg = self.foo_3(62).read_async().await?;
                                
                                callback(3 + 62 * 1000, "foo_3[62]", reg.into());
                            
                                
                                let reg = self.foo_3(63).read_async().await?;
                                
                                callback(3 + 63 * 1000, "foo_3[63]", reg.into());
                            
                                
                                let reg = self.foo_3(64).read_async().await?;
                                
                                callback(3 + 64 * 1000, "foo_3[64]", reg.into());
                            
                                
                                let reg = self.foo_3(65).read_async().await?;
                                
                                callback(3 + 65 * 1000, "foo_3[65]", reg.into());
                            
                                
                                let reg = self.foo_3(66).read_async().await?;
                                
                                callback(3 + 66 * 1000, "foo_3[66]", reg.into());
                            
                                
                                let reg = self.foo_3(67).read_async().await?;
                                
                                callback(3 + 67 * 1000, "foo_3[67]", reg.into());
                            
                                
                                let reg = self.foo_3(68).read_async().await?;
                                
                                callback(3 + 68 * 1000, "foo_3[68]", reg.into());
                            
                                
                                let reg = self.foo_3(69).read_async().await?;
                                
                                callback(3 + 69 * 1000, "foo_3[69]", reg.into());
                            
                                
                                let reg = self.foo_3(70).read_async().await?;
                                
                                callback(3 + 70 * 1000, "foo_3[70]", reg.into());
                            
                                
                                let reg = self.foo_3(71).read_async().await?;
                                
                                callback(3 + 71 * 1000, "foo_3[71]", reg.into());
                            
                                
                                let reg = self.foo_3(72).read_async().await?;
                                
                                callback(3 + 72 * 1000, "foo_3[72]", reg.into());
                            
                                
                                let reg = self.foo_3(73).read_async().await?;
                                
                                callback(3 + 73 * 1000, "foo_3[73]", reg.into());
                            
                                
                                let reg = self.foo_3(74).read_async().await?;
                                
                                callback(3 + 74 * 1000, "foo_3[74]", reg.into());
                            
                                
                                let reg = self.foo_3(75).read_async().await?;
                                
                                callback(3 + 75 * 1000, "foo_3[75]", reg.into());
                            
                                
                                let reg = self.foo_3(76).read_async().await?;
                                
                                callback(3 + 76 * 1000, "foo_3[76]", reg.into());
                            
                                
                                let reg = self.foo_3(77).read_async().await?;
                                
                                callback(3 + 77 * 1000, "foo_3[77]", reg.into());
                            
                                
                                let reg = self.foo_3(78).read_async().await?;
                                
                                callback(3 + 78 * 1000, "foo_3[78]", reg.into());
                            
                                
                                let reg = self.foo_3(79).read_async().await?;
                                
                                callback(3 + 79 * 1000, "foo_3[79]", reg.into());
                            
                                
                                let reg = self.foo_3(80).read_async().await?;
                                
                                callback(3 + 80 * 1000, "foo_3[80]", reg.into());
                            
                                
                                let reg = self.foo_3(81).read_async().await?;
                                
                                callback(3 + 81 * 1000, "foo_3[81]", reg.into());
                            
                                
                                let reg = self.foo_3(82).read_async().await?;
                                
                                callback(3 + 82 * 1000, "foo_3[82]", reg.into());
                            
                                
                                let reg = self.foo_3(83).read_async().await?;
                                
                                callback(3 + 83 * 1000, "foo_3[83]", reg.into());
                            
                                
                                let reg = self.foo_3(84).read_async().await?;
                                
                                callback(3 + 84 * 1000, "foo_3[84]", reg.into());
                            
                                
                                let reg = self.foo_3(85).read_async().await?;
                                
                                callback(3 + 85 * 1000, "foo_3[85]", reg.into());
                            
                                
                                let reg = self.foo_3(86).read_async().await?;
                                
                                callback(3 + 86 * 1000, "foo_3[86]", reg.into());
                            
                                
                                let reg = self.foo_3(87).read_async().await?;
                                
                                callback(3 + 87 * 1000, "foo_3[87]", reg.into());
                            
                                
                                let reg = self.foo_3(88).read_async().await?;
                                
                                callback(3 + 88 * 1000, "foo_3[88]", reg.into());
                            
                                
                                let reg = self.foo_3(89).read_async().await?;
                                
                                callback(3 + 89 * 1000, "foo_3[89]", reg.into());
                            
                                
                                let reg = self.foo_3(90).read_async().await?;
                                
                                callback(3 + 90 * 1000, "foo_3[90]", reg.into());
                            
                                
                                let reg = self.foo_3(91).read_async().await?;
                                
                                callback(3 + 91 * 1000, "foo_3[91]", reg.into());
                            
                                
                                let reg = self.foo_3(92).read_async().await?;
                                
                                callback(3 + 92 * 1000, "foo_3[92]", reg.into());
                            
                                
                                let reg = self.foo_3(93).read_async().await?;
                                
                                callback(3 + 93 * 1000, "foo_3[93]", reg.into());
                            
                                
                                let reg = self.foo_3(94).read_async().await?;
                                
                                callback(3 + 94 * 1000, "foo_3[94]", reg.into());
                            
                                
                                let reg = self.foo_3(95).read_async().await?;
                                
                                callback(3 + 95 * 1000, "foo_3[95]", reg.into());
                            
                                
                                let reg = self.foo_3(96).read_async().await?;
                                
                                callback(3 + 96 * 1000, "foo_3[96]", reg.into());
                            
                                
                                let reg = self.foo_3(97).read_async().await?;
                                
                                callback(3 + 97 * 1000, "foo_3[97]", reg.into());
                            
                                
                                let reg = self.foo_3(98).read_async().await?;
                                
                                callback(3 + 98 * 1000, "foo_3[98]", reg.into());
                            
                                
                                let reg = self.foo_3(99).read_async().await?;
                                
                                callback(3 + 99 * 1000, "foo_3[99]", reg.into());
                            
                        
                
            
        
            
                
                    
                            
                                
                                let reg = self.foo_4(0).read_async().await?;
                                
                                callback(4 + 0 * 1000, "foo_4[0]", reg.into());
                            
                                
                                let reg = self.foo_4(1).read_async().await?;
                                
                                callback(4 + 1 * 1000, "foo_4[1]", reg.into());
                            
                                
                                let reg = self.foo_4(2).read_async().await?;
                                
                                callback(4 + 2 * 1000, "foo_4[2]", reg.into());
                            
                                
                                let reg = self.foo_4(3).read_async().await?;
                                
                                callback(4 + 3 * 1000, "foo_4[3]", reg.into());
                            
                                
                                let reg = self.foo_4(4).read_async().await?;
                                
                                callback(4 + 4 * 1000, "foo_4[4]", reg.into());
                            
                                
                                let reg = self.foo_4(5).read_async().await?;
                                
                                callback(4 + 5 * 1000, "foo_4[5]", reg.into());
                            
                                
                                let reg = self.foo_4(6).read_async().await?;
                                
                                callback(4 + 6 * 1000, "foo_4[6]", reg.into());
                            
                                
                                let reg = self.foo_4(7).read_async().await?;
                                
                                callback(4 + 7 * 1000, "foo_4[7]", reg.into());
                            
                                
                                let reg = self.foo_4(8).read_async().await?;
                                
                                callback(4 + 8 * 1000, "foo_4[8]", reg.into());
                            
                                
                                let reg = self.foo_4(9).read_async().await?;
                                
                                callback(4 + 9 * 1000, "foo_4[9]", reg.into());
                            
                                
                                let reg = self.foo_4(10).read_async().await?;
                                
                                callback(4 + 10 * 1000, "foo_4[10]", reg.into());
                            
                                
                                let reg = self.foo_4(11).read_async().await?;
                                
                                callback(4 + 11 * 1000, "foo_4[11]", reg.into());
                            
                                
                                let reg = self.foo_4(12).read_async().await?;
                                
                                callback(4 + 12 * 1000, "foo_4[12]", reg.into());
                            
                                
                                let reg = self.foo_4(13).read_async().await?;
                                
                                callback(4 + 13 * 1000, "foo_4[13]", reg.into());
                            
                                
                                let reg = self.foo_4(14).read_async().await?;
                                
                                callback(4 + 14 * 1000, "foo_4[14]", reg.into());
                            
                                
                                let reg = self.foo_4(15).read_async().await?;
                                
                                callback(4 + 15 * 1000, "foo_4[15]", reg.into());
                            
                                
                                let reg = self.foo_4(16).read_async().await?;
                                
                                callback(4 + 16 * 1000, "foo_4[16]", reg.into());
                            
                                
                                let reg = self.foo_4(17).read_async().await?;
                                
                                callback(4 + 17 * 1000, "foo_4[17]", reg.into());
                            
                                
                                let reg = self.foo_4(18).read_async().await?;
                                
                                callback(4 + 18 * 1000, "foo_4[18]", reg.into());
                            
                                
                                let reg = self.foo_4(19).read_async().await?;
                                
                                callback(4 + 19 * 1000, "foo_4[19]", reg.into());
                            
                                
                                let reg = self.foo_4(20).read_async().await?;
                                
                                callback(4 + 20 * 1000, "foo_4[20]", reg.into());
                            
                                
                                let reg = self.foo_4(21).read_async().await?;
                                
                                callback(4 + 21 * 1000, "foo_4[21]", reg.into());
                            
                                
                                let reg = self.foo_4(22).read_async().await?;
                                
                                callback(4 + 22 * 1000, "foo_4[22]", reg.into());
                            
                                
                                let reg = self.foo_4(23).read_async().await?;
                                
                                callback(4 + 23 * 1000, "foo_4[23]", reg.into());
                            
                                
                                let reg = self.foo_4(24).read_async().await?;
                                
                                callback(4 + 24 * 1000, "foo_4[24]", reg.into());
                            
                                
                                let reg = self.foo_4(25).read_async().await?;
                                
                                callback(4 + 25 * 1000, "foo_4[25]", reg.into());
                            
                                
                                let reg = self.foo_4(26).read_async().await?;
                                
                                callback(4 + 26 * 1000, "foo_4[26]", reg.into());
                            
                                
                                let reg = self.foo_4(27).read_async().await?;
                                
                                callback(4 + 27 * 1000, "foo_4[27]", reg.into());
                            
                                
                                let reg = self.foo_4(28).read_async().await?;
                                
                                callback(4 + 28 * 1000, "foo_4[28]", reg.into());
                            
                                
                                let reg = self.foo_4(29).read_async().await?;
                                
                                callback(4 + 29 * 1000, "foo_4[29]", reg.into());
                            
                                
                                let reg = self.foo_4(30).read_async().await?;
                                
                                callback(4 + 30 * 1000, "foo_4[30]", reg.into());
                            
                                
                                let reg = self.foo_4(31).read_async().await?;
                                
                                callback(4 + 31 * 1000, "foo_4[31]", reg.into());
                            
                                
                                let reg = self.foo_4(32).read_async().await?;
                                
                                callback(4 + 32 * 1000, "foo_4[32]", reg.into());
                            
                                
                                let reg = self.foo_4(33).read_async().await?;
                                
                                callback(4 + 33 * 1000, "foo_4[33]", reg.into());
                            
                                
                                let reg = self.foo_4(34).read_async().await?;
                                
                                callback(4 + 34 * 1000, "foo_4[34]", reg.into());
                            
                                
                                let reg = self.foo_4(35).read_async().await?;
                                
                                callback(4 + 35 * 1000, "foo_4[35]", reg.into());
                            
                                
                                let reg = self.foo_4(36).read_async().await?;
                                
                                callback(4 + 36 * 1000, "foo_4[36]", reg.into());
                            
                                
                                let reg = self.foo_4(37).read_async().await?;
                                
                                callback(4 + 37 * 1000, "foo_4[37]", reg.into());
                            
                                
                                let reg = self.foo_4(38).read_async().await?;
                                
                                callback(4 + 38 * 1000, "foo_4[38]", reg.into());
                            
                                
                                let reg = self.foo_4(39).read_async().await?;
                                
                                callback(4 + 39 * 1000, "foo_4[39]", reg.into());
                            
                                
                                let reg = self.foo_4(40).read_async().await?;
                                
                                callback(4 + 40 * 1000, "foo_4[40]", reg.into());
                            
                                
                                let reg = self.foo_4(41).read_async().await?;
                                
                                callback(4 + 41 * 1000, "foo_4[41]", reg.into());
                            
                                
                                let reg = self.foo_4(42).read_async().await?;
                                
                                callback(4 + 42 * 1000, "foo_4[42]", reg.into());
                            
                                
                                let reg = self.foo_4(43).read_async().await?;
                                
                                callback(4 + 43 * 1000, "foo_4[43]", reg.into());
                            
                                
                                let reg = self.foo_4(44).read_async().await?;
                                
                                callback(4 + 44 * 1000, "foo_4[44]", reg.into());
                            
                                
                                let reg = self.foo_4(45).read_async().await?;
                                
                                callback(4 + 45 * 1000, "foo_4[45]", reg.into());
                            
                                
                                let reg = self.foo_4(46).read_async().await?;
                                
                                callback(4 + 46 * 1000, "foo_4[46]", reg.into());
                            
                                
                                let reg = self.foo_4(47).read_async().await?;
                                
                                callback(4 + 47 * 1000, "foo_4[47]", reg.into());
                            
                                
                                let reg = self.foo_4(48).read_async().await?;
                                
                                callback(4 + 48 * 1000, "foo_4[48]", reg.into());
                            
                                
                                let reg = self.foo_4(49).read_async().await?;
                                
                                callback(4 + 49 * 1000, "foo_4[49]", reg.into());
                            
                                
                                let reg = self.foo_4(50).read_async().await?;
                                
                                callback(4 + 50 * 1000, "foo_4[50]", reg.into());
                            
                                
                                let reg = self.foo_4(51).read_async().await?;
                                
                                callback(4 + 51 * 1000, "foo_4[51]", reg.into());
                            
                                
                                let reg = self.foo_4(52).read_async().await?;
                                
                                callback(4 + 52 * 1000, "foo_4[52]", reg.into());
                            
                                
                                let reg = self.foo_4(53).read_async().await?;
                                
                                callback(4 + 53 * 1000, "foo_4[53]", reg.into());
                            
                                
                                let reg = self.foo_4(54).read_async().await?;
                                
                                callback(4 + 54 * 1000, "foo_4[54]", reg.into());
                            
                                
                                let reg = self.foo_4(55).read_async().await?;
                                
                                callback(4 + 55 * 1000, "foo_4[55]", reg.into());
                            
                                
                                let reg = self.foo_4(56).read_async().await?;
                                
                                callback(4 + 56 * 1000, "foo_4[56]", reg.into());
                            
                                
                                let reg = self.foo_4(57).read_async().await?;
                                
                                callback(4 + 57 * 1000, "foo_4[57]", reg.into());
                            
                                
                                let reg = self.foo_4(58).read_async().await?;
                                
                                callback(4 + 58 * 1000, "foo_4[58]", reg.into());
                            
                                
                                let reg = self.foo_4(59).read_async().await?;
                                
                                callback(4 + 59 * 1000, "foo_4[59]", reg.into());
                            
                                
                                let reg = self.foo_4(60).read_async().await?;
                                
                                callback(4 + 60 * 1000, "foo_4[60]", reg.into());
                            
                                
                                let reg = self.foo_4(61).read_async().await?;
                                
                                callback(4 + 61 * 1000, "foo_4[61]", reg.into());
                            
                                
                                let reg = self.foo_4(62).read_async().await?;
                                
                                callback(4 + 62 * 1000, "foo_4[62]", reg.into());
                            
                                
                                let reg = self.foo_4(63).read_async().await?;
                                
                                callback(4 + 63 * 1000, "foo_4[63]", reg.into());
                            
                                
                                let reg = self.foo_4(64).read_async().await?;
                                
                                callback(4 + 64 * 1000, "foo_4[64]", reg.into());
                            
                                
                                let reg = self.foo_4(65).read_async().await?;
                                
                                callback(4 + 65 * 1000, "foo_4[65]", reg.into());
                            
                                
                                let reg = self.foo_4(66).read_async().await?;
                                
                                callback(4 + 66 * 1000, "foo_4[66]", reg.into());
                            
                                
                                let reg = self.foo_4(67).read_async().await?;
                                
                                callback(4 + 67 * 1000, "foo_4[67]", reg.into());
                            
                                
                                let reg = self.foo_4(68).read_async().await?;
                                
                                callback(4 + 68 * 1000, "foo_4[68]", reg.into());
                            
                                
                                let reg = self.foo_4(69).read_async().await?;
                                
                                callback(4 + 69 * 1000, "foo_4[69]", reg.into());
                            
                                
                                let reg = self.foo_4(70).read_async().await?;
                                
                                callback(4 + 70 * 1000, "foo_4[70]", reg.into());
                            
                                
                                let reg = self.foo_4(71).read_async().await?;
                                
                                callback(4 + 71 * 1000, "foo_4[71]", reg.into());
                            
                                
                                let reg = self.foo_4(72).read_async().await?;
                                
                                callback(4 + 72 * 1000, "foo_4[72]", reg.into());
                            
                                
                                let reg = self.foo_4(73).read_async().await?;
                                
                                callback(4 + 73 * 1000, "foo_4[73]", reg.into());
                            
                                
                                let reg = self.foo_4(74).read_async().await?;
                                
                                callback(4 + 74 * 1000, "foo_4[74]", reg.into());
                            
                                
                                let reg = self.foo_4(75).read_async().await?;
                                
                                callback(4 + 75 * 1000, "foo_4[75]", reg.into());
                            
                                
                                let reg = self.foo_4(76).read_async().await?;
                                
                                callback(4 + 76 * 1000, "foo_4[76]", reg.into());
                            
                                
                                let reg = self.foo_4(77).read_async().await?;
                                
                                callback(4 + 77 * 1000, "foo_4[77]", reg.into());
                            
                                
                                let reg = self.foo_4(78).read_async().await?;
                                
                                callback(4 + 78 * 1000, "foo_4[78]", reg.into());
                            
                                
                                let reg = self.foo_4(79).read_async().await?;
                                
                                callback(4 + 79 * 1000, "foo_4[79]", reg.into());
                            
                                
                                let reg = self.foo_4(80).read_async().await?;
                                
                                callback(4 + 80 * 1000, "foo_4[80]", reg.into());
                            
                                
                                let reg = self.foo_4(81).read_async().await?;
                                
                                callback(4 + 81 * 1000, "foo_4[81]", reg.into());
                            
                                
                                let reg = self.foo_4(82).read_async().await?;
                                
                                callback(4 + 82 * 1000, "foo_4[82]", reg.into());
                            
                                
                                let reg = self.foo_4(83).read_async().await?;
                                
                                callback(4 + 83 * 1000, "foo_4[83]", reg.into());
                            
                                
                                let reg = self.foo_4(84).read_async().await?;
                                
                                callback(4 + 84 * 1000, "foo_4[84]", reg.into());
                            
                                
                                let reg = self.foo_4(85).read_async().await?;
                                
                                callback(4 + 85 * 1000, "foo_4[85]", reg.into());
                            
                                
                                let reg = self.foo_4(86).read_async().await?;
                                
                                callback(4 + 86 * 1000, "foo_4[86]", reg.into());
                            
                                
                                let reg = self.foo_4(87).read_async().await?;
                                
                                callback(4 + 87 * 1000, "foo_4[87]", reg.into());
                            
                                
                                let reg = self.foo_4(88).read_async().await?;
                                
                                callback(4 + 88 * 1000, "foo_4[88]", reg.into());
                            
                                
                                let reg = self.foo_4(89).read_async().await?;
                                
                                callback(4 + 89 * 1000, "foo_4[89]", reg.into());
                            
                                
                                let reg = self.foo_4(90).read_async().await?;
                                
                                callback(4 + 90 * 1000, "foo_4[90]", reg.into());
                            
                                
                                let reg = self.foo_4(91).read_async().await?;
                                
                                callback(4 + 91 * 1000, "foo_4[91]", reg.into());
                            
                                
                                let reg = self.foo_4(92).read_async().await?;
                                
                                callback(4 + 92 * 1000, "foo_4[92]", reg.into());
                            
                                
                                let reg = self.foo_4(93).read_async().await?;
                                
                                callback(4 + 93 * 1000, "foo_4[93]", reg.into());
                            
                                
                                let reg = self.foo_4(94).read_async().await?;
                                
                                callback(4 + 94 * 1000, "foo_4[94]", reg.into());
                            
                                
                                let reg = self.foo_4(95).read_async().await?;
                                
                                callback(4 + 95 * 1000, "foo_4[95]", reg.into());
                            
                                
                                let reg = self.foo_4(96).read_async().await?;
                                
                                callback(4 + 96 * 1000, "foo_4[96]", reg.into());
                            
                                
                                let reg = self.foo_4(97).read_async().await?;
                                
                                callback(4 + 97 * 1000, "foo_4[97]", reg.into());
                            
                                
                                let reg = self.foo_4(98).read_async().await?;
                                
                                callback(4 + 98 * 1000, "foo_4[98]", reg.into());
                            
                                
                                let reg = self.foo_4(99).read_async().await?;
                                
                                callback(4 + 99 * 1000, "foo_4[99]", reg.into());
                            
                        
                
            
        
            
                
                    
                            
                                
                                let reg = self.foo_5(0).read_async().await?;
                                
                                callback(5 + 0 * 1000, "foo_5[0]", reg.into());
                            
                                
                                let reg = self.foo_5(1).read_async().await?;
                                
                                callback(5 + 1 * 1000, "foo_5[1]", reg.into());
                            
                                
                                let reg = self.foo_5(2).read_async().await?;
                                
                                callback(5 + 2 * 1000, "foo_5[2]", reg.into());
                            
                                
                                let reg = self.foo_5(3).read_async().await?;
                                
                                callback(5 + 3 * 1000, "foo_5[3]", reg.into());
                            
                                
                                let reg = self.foo_5(4).read_async().await?;
                                
                                callback(5 + 4 * 1000, "foo_5[4]", reg.into());
                            
                                
                                let reg = self.foo_5(5).read_async().await?;
                                
                                callback(5 + 5 * 1000, "foo_5[5]", reg.into());
                            
                                
                                let reg = self.foo_5(6).read_async().await?;
                                
                                callback(5 + 6 * 1000, "foo_5[6]", reg.into());
                            
                                
                                let reg = self.foo_5(7).read_async().await?;
                                
                                callback(5 + 7 * 1000, "foo_5[7]", reg.into());
                            
                                
                                let reg = self.foo_5(8).read_async().await?;
                                
                                callback(5 + 8 * 1000, "foo_5[8]", reg.into());
                            
                                
                                let reg = self.foo_5(9).read_async().await?;
                                
                                callback(5 + 9 * 1000, "foo_5[9]", reg.into());
                            
                                
                                let reg = self.foo_5(10).read_async().await?;
                                
                                callback(5 + 10 * 1000, "foo_5[10]", reg.into());
                            
                                
                                let reg = self.foo_5(11).read_async().await?;
                                
                                callback(5 + 11 * 1000, "foo_5[11]", reg.into());
                            
                                
                                let reg = self.foo_5(12).read_async().await?;
                                
                                callback(5 + 12 * 1000, "foo_5[12]", reg.into());
                            
                                
                                let reg = self.foo_5(13).read_async().await?;
                                
                                callback(5 + 13 * 1000, "foo_5[13]", reg.into());
                            
                                
                                let reg = self.foo_5(14).read_async().await?;
                                
                                callback(5 + 14 * 1000, "foo_5[14]", reg.into());
                            
                                
                                let reg = self.foo_5(15).read_async().await?;
                                
                                callback(5 + 15 * 1000, "foo_5[15]", reg.into());
                            
                                
                                let reg = self.foo_5(16).read_async().await?;
                                
                                callback(5 + 16 * 1000, "foo_5[16]", reg.into());
                            
                                
                                let reg = self.foo_5(17).read_async().await?;
                                
                                callback(5 + 17 * 1000, "foo_5[17]", reg.into());
                            
                                
                                let reg = self.foo_5(18).read_async().await?;
                                
                                callback(5 + 18 * 1000, "foo_5[18]", reg.into());
                            
                                
                                let reg = self.foo_5(19).read_async().await?;
                                
                                callback(5 + 19 * 1000, "foo_5[19]", reg.into());
                            
                                
                                let reg = self.foo_5(20).read_async().await?;
                                
                                callback(5 + 20 * 1000, "foo_5[20]", reg.into());
                            
                                
                                let reg = self.foo_5(21).read_async().await?;
                                
                                callback(5 + 21 * 1000, "foo_5[21]", reg.into());
                            
                                
                                let reg = self.foo_5(22).read_async().await?;
                                
                                callback(5 + 22 * 1000, "foo_5[22]", reg.into());
                            
                                
                                let reg = self.foo_5(23).read_async().await?;
                                
                                callback(5 + 23 * 1000, "foo_5[23]", reg.into());
                            
                                
                                let reg = self.foo_5(24).read_async().await?;
                                
                                callback(5 + 24 * 1000, "foo_5[24]", reg.into());
                            
                                
                                let reg = self.foo_5(25).read_async().await?;
                                
                                callback(5 + 25 * 1000, "foo_5[25]", reg.into());
                            
                                
                                let reg = self.foo_5(26).read_async().await?;
                                
                                callback(5 + 26 * 1000, "foo_5[26]", reg.into());
                            
                                
                                let reg = self.foo_5(27).read_async().await?;
                                
                                callback(5 + 27 * 1000, "foo_5[27]", reg.into());
                            
                                
                                let reg = self.foo_5(28).read_async().await?;
                                
                                callback(5 + 28 * 1000, "foo_5[28]", reg.into());
                            
                                
                                let reg = self.foo_5(29).read_async().await?;
                                
                                callback(5 + 29 * 1000, "foo_5[29]", reg.into());
                            
                                
                                let reg = self.foo_5(30).read_async().await?;
                                
                                callback(5 + 30 * 1000, "foo_5[30]", reg.into());
                            
                                
                                let reg = self.foo_5(31).read_async().await?;
                                
                                callback(5 + 31 * 1000, "foo_5[31]", reg.into());
                            
                                
                                let reg = self.foo_5(32).read_async().await?;
                                
                                callback(5 + 32 * 1000, "foo_5[32]", reg.into());
                            
                                
                                let reg = self.foo_5(33).read_async().await?;
                                
                                callback(5 + 33 * 1000, "foo_5[33]", reg.into());
                            
                                
                                let reg = self.foo_5(34).read_async().await?;
                                
                                callback(5 + 34 * 1000, "foo_5[34]", reg.into());
                            
                                
                                let reg = self.foo_5(35).read_async().await?;
                                
                                callback(5 + 35 * 1000, "foo_5[35]", reg.into());
                            
                                
                                let reg = self.foo_5(36).read_async().await?;
                                
                                callback(5 + 36 * 1000, "foo_5[36]", reg.into());
                            
                                
                                let reg = self.foo_5(37).read_async().await?;
                                
                                callback(5 + 37 * 1000, "foo_5[37]", reg.into());
                            
                                
                                let reg = self.foo_5(38).read_async().await?;
                                
                                callback(5 + 38 * 1000, "foo_5[38]", reg.into());
                            
                                
                                let reg = self.foo_5(39).read_async().await?;
                                
                                callback(5 + 39 * 1000, "foo_5[39]", reg.into());
                            
                                
                                let reg = self.foo_5(40).read_async().await?;
                                
                                callback(5 + 40 * 1000, "foo_5[40]", reg.into());
                            
                                
                                let reg = self.foo_5(41).read_async().await?;
                                
                                callback(5 + 41 * 1000, "foo_5[41]", reg.into());
                            
                                
                                let reg = self.foo_5(42).read_async().await?;
                                
                                callback(5 + 42 * 1000, "foo_5[42]", reg.into());
                            
                                
                                let reg = self.foo_5(43).read_async().await?;
                                
                                callback(5 + 43 * 1000, "foo_5[43]", reg.into());
                            
                                
                                let reg = self.foo_5(44).read_async().await?;
                                
                                callback(5 + 44 * 1000, "foo_5[44]", reg.into());
                            
                                
                                let reg = self.foo_5(45).read_async().await?;
                                
                                callback(5 + 45 * 1000, "foo_5[45]", reg.into());
                            
                                
                                let reg = self.foo_5(46).read_async().await?;
                                
                                callback(5 + 46 * 1000, "foo_5[46]", reg.into());
                            
                                
                                let reg = self.foo_5(47).read_async().await?;
                                
                                callback(5 + 47 * 1000, "foo_5[47]", reg.into());
                            
                                
                                let reg = self.foo_5(48).read_async().await?;
                                
                                callback(5 + 48 * 1000, "foo_5[48]", reg.into());
                            
                                
                                let reg = self.foo_5(49).read_async().await?;
                                
                                callback(5 + 49 * 1000, "foo_5[49]", reg.into());
                            
                                
                                let reg = self.foo_5(50).read_async().await?;
                                
                                callback(5 + 50 * 1000, "foo_5[50]", reg.into());
                            
                                
                                let reg = self.foo_5(51).read_async().await?;
                                
                                callback(5 + 51 * 1000, "foo_5[51]", reg.into());
                            
                                
                                let reg = self.foo_5(52).read_async().await?;
                                
                                callback(5 + 52 * 1000, "foo_5[52]", reg.into());
                            
                                
                                let reg = self.foo_5(53).read_async().await?;
                                
                                callback(5 + 53 * 1000, "foo_5[53]", reg.into());
                            
                                
                                let reg = self.foo_5(54).read_async().await?;
                                
                                callback(5 + 54 * 1000, "foo_5[54]", reg.into());
                            
                                
                                let reg = self.foo_5(55).read_async().await?;
                                
                                callback(5 + 55 * 1000, "foo_5[55]", reg.into());
                            
                                
                                let reg = self.foo_5(56).read_async().await?;
                                
                                callback(5 + 56 * 1000, "foo_5[56]", reg.into());
                            
                                
                                let reg = self.foo_5(57).read_async().await?;
                                
                                callback(5 + 57 * 1000, "foo_5[57]", reg.into());
                            
                                
                                let reg = self.foo_5(58).read_async().await?;
                                
                                callback(5 + 58 * 1000, "foo_5[58]", reg.into());
                            
                                
                                let reg = self.foo_5(59).read_async().await?;
                                
                                callback(5 + 59 * 1000, "foo_5[59]", reg.into());
                            
                                
                                let reg = self.foo_5(60).read_async().await?;
                                
                                callback(5 + 60 * 1000, "foo_5[60]", reg.into());
                            
                                
                                let reg = self.foo_5(61).read_async().await?;
                                
                                callback(5 + 61 * 1000, "foo_5[61]", reg.into());
                            
                                
                                let reg = self.foo_5(62).read_async().await?;
                                
                                callback(5 + 62 * 1000, "foo_5[62]", reg.into());
                            
                                
                                let reg = self.foo_5(63).read_async().await?;
                                
                                callback(5 + 63 * 1000, "foo_5[63]", reg.into());
                            
                                
                                let reg = self.foo_5(64).read_async().await?;
                                
                                callback(5 + 64 * 1000, "foo_5[64]", reg.into());
                            
                                
                                let reg = self.foo_5(65).read_async().await?;
                                
                                callback(5 + 65 * 1000, "foo_5[65]", reg.into());
                            
                                
                                let reg = self.foo_5(66).read_async().await?;
                                
                                callback(5 + 66 * 1000, "foo_5[66]", reg.into());
                            
                                
                                let reg = self.foo_5(67).read_async().await?;
                                
                                callback(5 + 67 * 1000, "foo_5[67]", reg.into());
                            
                                
                                let reg = self.foo_5(68).read_async().await?;
                                
                                callback(5 + 68 * 1000, "foo_5[68]", reg.into());
                            
                                
                                let reg = self.foo_5(69).read_async().await?;
                                
                                callback(5 + 69 * 1000, "foo_5[69]", reg.into());
                            
                                
                                let reg = self.foo_5(70).read_async().await?;
                                
                                callback(5 + 70 * 1000, "foo_5[70]", reg.into());
                            
                                
                                let reg = self.foo_5(71).read_async().await?;
                                
                                callback(5 + 71 * 1000, "foo_5[71]", reg.into());
                            
                                
                                let reg = self.foo_5(72).read_async().await?;
                                
                                callback(5 + 72 * 1000, "foo_5[72]", reg.into());
                            
                                
                                let reg = self.foo_5(73).read_async().await?;
                                
                                callback(5 + 73 * 1000, "foo_5[73]", reg.into());
                            
                                
                                let reg = self.foo_5(74).read_async().await?;
                                
                                callback(5 + 74 * 1000, "foo_5[74]", reg.into());
                            
                                
                                let reg = self.foo_5(75).read_async().await?;
                                
                                callback(5 + 75 * 1000, "foo_5[75]", reg.into());
                            
                                
                                let reg = self.foo_5(76).read_async().await?;
                                
                                callback(5 + 76 * 1000, "foo_5[76]", reg.into());
                            
                                
                                let reg = self.foo_5(77).read_async().await?;
                                
                                callback(5 + 77 * 1000, "foo_5[77]", reg.into());
                            
                                
                                let reg = self.foo_5(78).read_async().await?;
                                
                                callback(5 + 78 * 1000, "foo_5[78]", reg.into());
                            
                                
                                let reg = self.foo_5(79).read_async().await?;
                                
                                callback(5 + 79 * 1000, "foo_5[79]", reg.into());
                            
                                
                                let reg = self.foo_5(80).read_async().await?;
                                
                                callback(5 + 80 * 1000, "foo_5[80]", reg.into());
                            
                                
                                let reg = self.foo_5(81).read_async().await?;
                                
                                callback(5 + 81 * 1000, "foo_5[81]", reg.into());
                            
                                
                                let reg = self.foo_5(82).read_async().await?;
                                
                                callback(5 + 82 * 1000, "foo_5[82]", reg.into());
                            
                                
                                let reg = self.foo_5(83).read_async().await?;
                                
                                callback(5 + 83 * 1000, "foo_5[83]", reg.into());
                            
                                
                                let reg = self.foo_5(84).read_async().await?;
                                
                                callback(5 + 84 * 1000, "foo_5[84]", reg.into());
                            
                                
                                let reg = self.foo_5(85).read_async().await?;
                                
                                callback(5 + 85 * 1000, "foo_5[85]", reg.into());
                            
                                
                                let reg = self.foo_5(86).read_async().await?;
                                
                                callback(5 + 86 * 1000, "foo_5[86]", reg.into());
                            
                                
                                let reg = self.foo_5(87).read_async().await?;
                                
                                callback(5 + 87 * 1000, "foo_5[87]", reg.into());
                            
                                
                                let reg = self.foo_5(88).read_async().await?;
                                
                                callback(5 + 88 * 1000, "foo_5[88]", reg.into());
                            
                                
                                let reg = self.foo_5(89).read_async().await?;
                                
                                callback(5 + 89 * 1000, "foo_5[89]", reg.into());
                            
                                
                                let reg = self.foo_5(90).read_async().await?;
                                
                                callback(5 + 90 * 1000, "foo_5[90]", reg.into());
                            
                                
                                let reg = self.foo_5(91).read_async().await?;
                                
                                callback(5 + 91 * 1000, "foo_5[91]", reg.into());
                            
                                
                                let reg = self.foo_5(92).read_async().await?;
                                
                                callback(5 + 92 * 1000, "foo_5[92]", reg.into());
                            
                                
                                let reg = self.foo_5(93).read_async().await?;
                                
                                callback(5 + 93 * 1000, "foo_5[93]", reg.into());
                            
                                
                                let reg = self.foo_5(94).read_async().await?;
                                
                                callback(5 + 94 * 1000, "foo_5[94]", reg.into());
                            
                                
                                let reg = self.foo_5(95).read_async().await?;
                                
                                callback(5 + 95 * 1000, "foo_5[95]", reg.into());
                            
                                
                                let reg = self.foo_5(96).read_async().await?;
                                
                                callback(5 + 96 * 1000, "foo_5[96]", reg.into());
                            
                                
                                let reg = self.foo_5(97).read_async().await?;
                                
                                callback(5 + 97 * 1000, "foo_5[97]", reg.into());
                            
                                
                                let reg = self.foo_5(98).read_async().await?;
                                
                                callback(5 + 98 * 1000, "foo_5[98]", reg.into());
                            
                                
                                let reg = self.foo_5(99).read_async().await?;
                                
                                callback(5 + 99 * 1000, "foo_5[99]", reg.into());
                            
                        
                
            
        
            
                
                    
                            
                                
                                let reg = self.foo_6(0).read_async().await?;
                                
                                callback(6 + 0 * 1000, "foo_6[0]", reg.into());
                            
                                
                                let reg = self.foo_6(1).read_async().await?;
                                
                                callback(6 + 1 * 1000, "foo_6[1]", reg.into());
                            
                                
                                let reg = self.foo_6(2).read_async().await?;
                                
                                callback(6 + 2 * 1000, "foo_6[2]", reg.into());
                            
                                
                                let reg = self.foo_6(3).read_async().await?;
                                
                                callback(6 + 3 * 1000, "foo_6[3]", reg.into());
                            
                                
                                let reg = self.foo_6(4).read_async().await?;
                                
                                callback(6 + 4 * 1000, "foo_6[4]", reg.into());
                            
                                
                                let reg = self.foo_6(5).read_async().await?;
                                
                                callback(6 + 5 * 1000, "foo_6[5]", reg.into());
                            
                                
                                let reg = self.foo_6(6).read_async().await?;
                                
                                callback(6 + 6 * 1000, "foo_6[6]", reg.into());
                            
                                
                                let reg = self.foo_6(7).read_async().await?;
                                
                                callback(6 + 7 * 1000, "foo_6[7]", reg.into());
                            
                                
                                let reg = self.foo_6(8).read_async().await?;
                                
                                callback(6 + 8 * 1000, "foo_6[8]", reg.into());
                            
                                
                                let reg = self.foo_6(9).read_async().await?;
                                
                                callback(6 + 9 * 1000, "foo_6[9]", reg.into());
                            
                                
                                let reg = self.foo_6(10).read_async().await?;
                                
                                callback(6 + 10 * 1000, "foo_6[10]", reg.into());
                            
                                
                                let reg = self.foo_6(11).read_async().await?;
                                
                                callback(6 + 11 * 1000, "foo_6[11]", reg.into());
                            
                                
                                let reg = self.foo_6(12).read_async().await?;
                                
                                callback(6 + 12 * 1000, "foo_6[12]", reg.into());
                            
                                
                                let reg = self.foo_6(13).read_async().await?;
                                
                                callback(6 + 13 * 1000, "foo_6[13]", reg.into());
                            
                                
                                let reg = self.foo_6(14).read_async().await?;
                                
                                callback(6 + 14 * 1000, "foo_6[14]", reg.into());
                            
                                
                                let reg = self.foo_6(15).read_async().await?;
                                
                                callback(6 + 15 * 1000, "foo_6[15]", reg.into());
                            
                                
                                let reg = self.foo_6(16).read_async().await?;
                                
                                callback(6 + 16 * 1000, "foo_6[16]", reg.into());
                            
                                
                                let reg = self.foo_6(17).read_async().await?;
                                
                                callback(6 + 17 * 1000, "foo_6[17]", reg.into());
                            
                                
                                let reg = self.foo_6(18).read_async().await?;
                                
                                callback(6 + 18 * 1000, "foo_6[18]", reg.into());
                            
                                
                                let reg = self.foo_6(19).read_async().await?;
                                
                                callback(6 + 19 * 1000, "foo_6[19]", reg.into());
                            
                                
                                let reg = self.foo_6(20).read_async().await?;
                                
                                callback(6 + 20 * 1000, "foo_6[20]", reg.into());
                            
                                
                                let reg = self.foo_6(21).read_async().await?;
                                
                                callback(6 + 21 * 1000, "foo_6[21]", reg.into());
                            
                                
                                let reg = self.foo_6(22).read_async().await?;
                                
                                callback(6 + 22 * 1000, "foo_6[22]", reg.into());
                            
                                
                                let reg = self.foo_6(23).read_async().await?;
                                
                                callback(6 + 23 * 1000, "foo_6[23]", reg.into());
                            
                                
                                let reg = self.foo_6(24).read_async().await?;
                                
                                callback(6 + 24 * 1000, "foo_6[24]", reg.into());
                            
                                
                                let reg = self.foo_6(25).read_async().await?;
                                
                                callback(6 + 25 * 1000, "foo_6[25]", reg.into());
                            
                                
                                let reg = self.foo_6(26).read_async().await?;
                                
                                callback(6 + 26 * 1000, "foo_6[26]", reg.into());
                            
                                
                                let reg = self.foo_6(27).read_async().await?;
                                
                                callback(6 + 27 * 1000, "foo_6[27]", reg.into());
                            
                                
                                let reg = self.foo_6(28).read_async().await?;
                                
                                callback(6 + 28 * 1000, "foo_6[28]", reg.into());
                            
                                
                                let reg = self.foo_6(29).read_async().await?;
                                
                                callback(6 + 29 * 1000, "foo_6[29]", reg.into());
                            
                                
                                let reg = self.foo_6(30).read_async().await?;
                                
                                callback(6 + 30 * 1000, "foo_6[30]", reg.into());
                            
                                
                                let reg = self.foo_6(31).read_async().await?;
                                
                                callback(6 + 31 * 1000, "foo_6[31]", reg.into());
                            
                                
                                let reg = self.foo_6(32).read_async().await?;
                                
                                callback(6 + 32 * 1000, "foo_6[32]", reg.into());
                            
                                
                                let reg = self.foo_6(33).read_async().await?;
                                
                                callback(6 + 33 * 1000, "foo_6[33]", reg.into());
                            
                                
                                let reg = self.foo_6(34).read_async().await?;
                                
                                callback(6 + 34 * 1000, "foo_6[34]", reg.into());
                            
                                
                                let reg = self.foo_6(35).read_async().await?;
                                
                                callback(6 + 35 * 1000, "foo_6[35]", reg.into());
                            
                                
                                let reg = self.foo_6(36).read_async().await?;
                                
                                callback(6 + 36 * 1000, "foo_6[36]", reg.into());
                            
                                
                                let reg = self.foo_6(37).read_async().await?;
                                
                                callback(6 + 37 * 1000, "foo_6[37]", reg.into());
                            
                                
                                let reg = self.foo_6(38).read_async().await?;
                                
                                callback(6 + 38 * 1000, "foo_6[38]", reg.into());
                            
                                
                                let reg = self.foo_6(39).read_async().await?;
                                
                                callback(6 + 39 * 1000, "foo_6[39]", reg.into());
                            
                                
                                let reg = self.foo_6(40).read_async().await?;
                                
                                callback(6 + 40 * 1000, "foo_6[40]", reg.into());
                            
                                
                                let reg = self.foo_6(41).read_async().await?;
                                
                                callback(6 + 41 * 1000, "foo_6[41]", reg.into());
                            
                                
                                let reg = self.foo_6(42).read_async().await?;
                                
                                callback(6 + 42 * 1000, "foo_6[42]", reg.into());
                            
                                
                                let reg = self.foo_6(43).read_async().await?;
                                
                                callback(6 + 43 * 1000, "foo_6[43]", reg.into());
                            
                                
                                let reg = self.foo_6(44).read_async().await?;
                                
                                callback(6 + 44 * 1000, "foo_6[44]", reg.into());
                            
                                
                                let reg = self.foo_6(45).read_async().await?;
                                
                                callback(6 + 45 * 1000, "foo_6[45]", reg.into());
                            
                                
                                let reg = self.foo_6(46).read_async().await?;
                                
                                callback(6 + 46 * 1000, "foo_6[46]", reg.into());
                            
                                
                                let reg = self.foo_6(47).read_async().await?;
                                
                                callback(6 + 47 * 1000, "foo_6[47]", reg.into());
                            
                                
                                let reg = self.foo_6(48).read_async().await?;
                                
                                callback(6 + 48 * 1000, "foo_6[48]", reg.into());
                            
                                
                                let reg = self.foo_6(49).read_async().await?;
                                
                                callback(6 + 49 * 1000, "foo_6[49]", reg.into());
                            
                                
                                let reg = self.foo_6(50).read_async().await?;
                                
                                callback(6 + 50 * 1000, "foo_6[50]", reg.into());
                            
                                
                                let reg = self.foo_6(51).read_async().await?;
                                
                                callback(6 + 51 * 1000, "foo_6[51]", reg.into());
                            
                                
                                let reg = self.foo_6(52).read_async().await?;
                                
                                callback(6 + 52 * 1000, "foo_6[52]", reg.into());
                            
                                
                                let reg = self.foo_6(53).read_async().await?;
                                
                                callback(6 + 53 * 1000, "foo_6[53]", reg.into());
                            
                                
                                let reg = self.foo_6(54).read_async().await?;
                                
                                callback(6 + 54 * 1000, "foo_6[54]", reg.into());
                            
                                
                                let reg = self.foo_6(55).read_async().await?;
                                
                                callback(6 + 55 * 1000, "foo_6[55]", reg.into());
                            
                                
                                let reg = self.foo_6(56).read_async().await?;
                                
                                callback(6 + 56 * 1000, "foo_6[56]", reg.into());
                            
                                
                                let reg = self.foo_6(57).read_async().await?;
                                
                                callback(6 + 57 * 1000, "foo_6[57]", reg.into());
                            
                                
                                let reg = self.foo_6(58).read_async().await?;
                                
                                callback(6 + 58 * 1000, "foo_6[58]", reg.into());
                            
                                
                                let reg = self.foo_6(59).read_async().await?;
                                
                                callback(6 + 59 * 1000, "foo_6[59]", reg.into());
                            
                                
                                let reg = self.foo_6(60).read_async().await?;
                                
                                callback(6 + 60 * 1000, "foo_6[60]", reg.into());
                            
                                
                                let reg = self.foo_6(61).read_async().await?;
                                
                                callback(6 + 61 * 1000, "foo_6[61]", reg.into());
                            
                                
                                let reg = self.foo_6(62).read_async().await?;
                                
                                callback(6 + 62 * 1000, "foo_6[62]", reg.into());
                            
                                
                                let reg = self.foo_6(63).read_async().await?;
                                
                                callback(6 + 63 * 1000, "foo_6[63]", reg.into());
                            
                                
                                let reg = self.foo_6(64).read_async().await?;
                                
                                callback(6 + 64 * 1000, "foo_6[64]", reg.into());
                            
                                
                                let reg = self.foo_6(65).read_async().await?;
                                
                                callback(6 + 65 * 1000, "foo_6[65]", reg.into());
                            
                                
                                let reg = self.foo_6(66).read_async().await?;
                                
                                callback(6 + 66 * 1000, "foo_6[66]", reg.into());
                            
                                
                                let reg = self.foo_6(67).read_async().await?;
                                
                                callback(6 + 67 * 1000, "foo_6[67]", reg.into());
                            
                                
                                let reg = self.foo_6(68).read_async().await?;
                                
                                callback(6 + 68 * 1000, "foo_6[68]", reg.into());
                            
                                
                                let reg = self.foo_6(69).read_async().await?;
                                
                                callback(6 + 69 * 1000, "foo_6[69]", reg.into());
                            
                                
                                let reg = self.foo_6(70).read_async().await?;
                                
                                callback(6 + 70 * 1000, "foo_6[70]", reg.into());
                            
                                
                                let reg = self.foo_6(71).read_async().await?;
                                
                                callback(6 + 71 * 1000, "foo_6[71]", reg.into());
                            
                                
                                let reg = self.foo_6(72).read_async().await?;
                                
                                callback(6 + 72 * 1000, "foo_6[72]", reg.into());
                            
                                
                                let reg = self.foo_6(73).read_async().await?;
                                
                                callback(6 + 73 * 1000, "foo_6[73]", reg.into());
                            
                                
                                let reg = self.foo_6(74).read_async().await?;
                                
                                callback(6 + 74 * 1000, "foo_6[74]", reg.into());
                            
                                
                                let reg = self.foo_6(75).read_async().await?;
                                
                                callback(6 + 75 * 1000, "foo_6[75]", reg.into());
                            
                                
                                let reg = self.foo_6(76).read_async().await?;
                                
                                callback(6 + 76 * 1000, "foo_6[76]", reg.into());
                            
                                
                                let reg = self.foo_6(77).read_async().await?;
                                
                                callback(6 + 77 * 1000, "foo_6[77]", reg.into());
                            
                                
                                let reg = self.foo_6(78).read_async().await?;
                                
                                callback(6 + 78 * 1000, "foo_6[78]", reg.into());
                            
                                
                                let reg = self.foo_6(79).read_async().await?;
                                
                                callback(6 + 79 * 1000, "foo_6[79]", reg.into());
                            
                                
                                let reg = self.foo_6(80).read_async().await?;
                                
                                callback(6 + 80 * 1000, "foo_6[80]", reg.into());
                            
                                
                                let reg = self.foo_6(81).read_async().await?;
                                
                                callback(6 + 81 * 1000, "foo_6[81]", reg.into());
                            
                                
                                let reg = self.foo_6(82).read_async().await?;
                                
                                callback(6 + 82 * 1000, "foo_6[82]", reg.into());
                            
                                
                                let reg = self.foo_6(83).read_async().await?;
                                
                                callback(6 + 83 * 1000, "foo_6[83]", reg.into());
                            
                                
                                let reg = self.foo_6(84).read_async().await?;
                                
                                callback(6 + 84 * 1000, "foo_6[84]", reg.into());
                            
                                
                                let reg = self.foo_6(85).read_async().await?;
                                
                                callback(6 + 85 * 1000, "foo_6[85]", reg.into());
                            
                                
                                let reg = self.foo_6(86).read_async().await?;
                                
                                callback(6 + 86 * 1000, "foo_6[86]", reg.into());
                            
                                
                                let reg = self.foo_6(87).read_async().await?;
                                
                                callback(6 + 87 * 1000, "foo_6[87]", reg.into());
                            
                                
                                let reg = self.foo_6(88).read_async().await?;
                                
                                callback(6 + 88 * 1000, "foo_6[88]", reg.into());
                            
                                
                                let reg = self.foo_6(89).read_async().await?;
                                
                                callback(6 + 89 * 1000, "foo_6[89]", reg.into());
                            
                                
                                let reg = self.foo_6(90).read_async().await?;
                                
                                callback(6 + 90 * 1000, "foo_6[90]", reg.into());
                            
                                
                                let reg = self.foo_6(91).read_async().await?;
                                
                                callback(6 + 91 * 1000, "foo_6[91]", reg.into());
                            
                                
                                let reg = self.foo_6(92).read_async().await?;
                                
                                callback(6 + 92 * 1000, "foo_6[92]", reg.into());
                            
                                
                                let reg = self.foo_6(93).read_async().await?;
                                
                                callback(6 + 93 * 1000, "foo_6[93]", reg.into());
                            
                                
                                let reg = self.foo_6(94).read_async().await?;
                                
                                callback(6 + 94 * 1000, "foo_6[94]", reg.into());
                            
                                
                                let reg = self.foo_6(95).read_async().await?;
                                
                                callback(6 + 95 * 1000, "foo_6[95]", reg.into());
                            
                                
                                let reg = self.foo_6(96).read_async().await?;
                                
                                callback(6 + 96 * 1000, "foo_6[96]", reg.into());
                            
                                
                                let reg = self.foo_6(97).read_async().await?;
                                
                                callback(6 + 97 * 1000, "foo_6[97]", reg.into());
                            
                                
                                let reg = self.foo_6(98).read_async().await?;
                                
                                callback(6 + 98 * 1000, "foo_6[98]", reg.into());
                            
                                
                                let reg = self.foo_6(99).read_async().await?;
                                
                                callback(6 + 99 * 1000, "foo_6[99]", reg.into());
                            
                        
                
            
        
            
                
                    
                            
                                
                                let reg = self.foo_7(0).read_async().await?;
                                
                                callback(7 + 0 * 1000, "foo_7[0]", reg.into());
                            
                                
                                let reg = self.foo_7(1).read_async().await?;
                                
                                callback(7 + 1 * 1000, "foo_7[1]", reg.into());
                            
                                
                                let reg = self.foo_7(2).read_async().await?;
                                
                                callback(7 + 2 * 1000, "foo_7[2]", reg.into());
                            
                                
                                let reg = self.foo_7(3).read_async().await?;
                                
                                callback(7 + 3 * 1000, "foo_7[3]", reg.into());
                            
                                
                                let reg = self.foo_7(4).read_async().await?;
                                
                                callback(7 + 4 * 1000, "foo_7[4]", reg.into());
                            
                                
                                let reg = self.foo_7(5).read_async().await?;
                                
                                callback(7 + 5 * 1000, "foo_7[5]", reg.into());
                            
                                
                                let reg = self.foo_7(6).read_async().await?;
                                
                                callback(7 + 6 * 1000, "foo_7[6]", reg.into());
                            
                                
                                let reg = self.foo_7(7).read_async().await?;
                                
                                callback(7 + 7 * 1000, "foo_7[7]", reg.into());
                            
                                
                                let reg = self.foo_7(8).read_async().await?;
                                
                                callback(7 + 8 * 1000, "foo_7[8]", reg.into());
                            
                                
                                let reg = self.foo_7(9).read_async().await?;
                                
                                callback(7 + 9 * 1000, "foo_7[9]", reg.into());
                            
                                
                                let reg = self.foo_7(10).read_async().await?;
                                
                                callback(7 + 10 * 1000, "foo_7[10]", reg.into());
                            
                                
                                let reg = self.foo_7(11).read_async().await?;
                                
                                callback(7 + 11 * 1000, "foo_7[11]", reg.into());
                            
                                
                                let reg = self.foo_7(12).read_async().await?;
                                
                                callback(7 + 12 * 1000, "foo_7[12]", reg.into());
                            
                                
                                let reg = self.foo_7(13).read_async().await?;
                                
                                callback(7 + 13 * 1000, "foo_7[13]", reg.into());
                            
                                
                                let reg = self.foo_7(14).read_async().await?;
                                
                                callback(7 + 14 * 1000, "foo_7[14]", reg.into());
                            
                                
                                let reg = self.foo_7(15).read_async().await?;
                                
                                callback(7 + 15 * 1000, "foo_7[15]", reg.into());
                            
                                
                                let reg = self.foo_7(16).read_async().await?;
                                
                                callback(7 + 16 * 1000, "foo_7[16]", reg.into());
                            
                                
                                let reg = self.foo_7(17).read_async().await?;
                                
                                callback(7 + 17 * 1000, "foo_7[17]", reg.into());
                            
                                
                                let reg = self.foo_7(18).read_async().await?;
                                
                                callback(7 + 18 * 1000, "foo_7[18]", reg.into());
                            
                                
                                let reg = self.foo_7(19).read_async().await?;
                                
                                callback(7 + 19 * 1000, "foo_7[19]", reg.into());
                            
                                
                                let reg = self.foo_7(20).read_async().await?;
                                
                                callback(7 + 20 * 1000, "foo_7[20]", reg.into());
                            
                                
                                let reg = self.foo_7(21).read_async().await?;
                                
                                callback(7 + 21 * 1000, "foo_7[21]", reg.into());
                            
                                
                                let reg = self.foo_7(22).read_async().await?;
                                
                                callback(7 + 22 * 1000, "foo_7[22]", reg.into());
                            
                                
                                let reg = self.foo_7(23).read_async().await?;
                                
                                callback(7 + 23 * 1000, "foo_7[23]", reg.into());
                            
                                
                                let reg = self.foo_7(24).read_async().await?;
                                
                                callback(7 + 24 * 1000, "foo_7[24]", reg.into());
                            
                                
                                let reg = self.foo_7(25).read_async().await?;
                                
                                callback(7 + 25 * 1000, "foo_7[25]", reg.into());
                            
                                
                                let reg = self.foo_7(26).read_async().await?;
                                
                                callback(7 + 26 * 1000, "foo_7[26]", reg.into());
                            
                                
                                let reg = self.foo_7(27).read_async().await?;
                                
                                callback(7 + 27 * 1000, "foo_7[27]", reg.into());
                            
                                
                                let reg = self.foo_7(28).read_async().await?;
                                
                                callback(7 + 28 * 1000, "foo_7[28]", reg.into());
                            
                                
                                let reg = self.foo_7(29).read_async().await?;
                                
                                callback(7 + 29 * 1000, "foo_7[29]", reg.into());
                            
                                
                                let reg = self.foo_7(30).read_async().await?;
                                
                                callback(7 + 30 * 1000, "foo_7[30]", reg.into());
                            
                                
                                let reg = self.foo_7(31).read_async().await?;
                                
                                callback(7 + 31 * 1000, "foo_7[31]", reg.into());
                            
                                
                                let reg = self.foo_7(32).read_async().await?;
                                
                                callback(7 + 32 * 1000, "foo_7[32]", reg.into());
                            
                                
                                let reg = self.foo_7(33).read_async().await?;
                                
                                callback(7 + 33 * 1000, "foo_7[33]", reg.into());
                            
                                
                                let reg = self.foo_7(34).read_async().await?;
                                
                                callback(7 + 34 * 1000, "foo_7[34]", reg.into());
                            
                                
                                let reg = self.foo_7(35).read_async().await?;
                                
                                callback(7 + 35 * 1000, "foo_7[35]", reg.into());
                            
                                
                                let reg = self.foo_7(36).read_async().await?;
                                
                                callback(7 + 36 * 1000, "foo_7[36]", reg.into());
                            
                                
                                let reg = self.foo_7(37).read_async().await?;
                                
                                callback(7 + 37 * 1000, "foo_7[37]", reg.into());
                            
                                
                                let reg = self.foo_7(38).read_async().await?;
                                
                                callback(7 + 38 * 1000, "foo_7[38]", reg.into());
                            
                                
                                let reg = self.foo_7(39).read_async().await?;
                                
                                callback(7 + 39 * 1000, "foo_7[39]", reg.into());
                            
                                
                                let reg = self.foo_7(40).read_async().await?;
                                
                                callback(7 + 40 * 1000, "foo_7[40]", reg.into());
                            
                                
                                let reg = self.foo_7(41).read_async().await?;
                                
                                callback(7 + 41 * 1000, "foo_7[41]", reg.into());
                            
                                
                                let reg = self.foo_7(42).read_async().await?;
                                
                                callback(7 + 42 * 1000, "foo_7[42]", reg.into());
                            
                                
                                let reg = self.foo_7(43).read_async().await?;
                                
                                callback(7 + 43 * 1000, "foo_7[43]", reg.into());
                            
                                
                                let reg = self.foo_7(44).read_async().await?;
                                
                                callback(7 + 44 * 1000, "foo_7[44]", reg.into());
                            
                                
                                let reg = self.foo_7(45).read_async().await?;
                                
                                callback(7 + 45 * 1000, "foo_7[45]", reg.into());
                            
                                
                                let reg = self.foo_7(46).read_async().await?;
                                
                                callback(7 + 46 * 1000, "foo_7[46]", reg.into());
                            
                                
                                let reg = self.foo_7(47).read_async().await?;
                                
                                callback(7 + 47 * 1000, "foo_7[47]", reg.into());
                            
                                
                                let reg = self.foo_7(48).read_async().await?;
                                
                                callback(7 + 48 * 1000, "foo_7[48]", reg.into());
                            
                                
                                let reg = self.foo_7(49).read_async().await?;
                                
                                callback(7 + 49 * 1000, "foo_7[49]", reg.into());
                            
                                
                                let reg = self.foo_7(50).read_async().await?;
                                
                                callback(7 + 50 * 1000, "foo_7[50]", reg.into());
                            
                                
                                let reg = self.foo_7(51).read_async().await?;
                                
                                callback(7 + 51 * 1000, "foo_7[51]", reg.into());
                            
                                
                                let reg = self.foo_7(52).read_async().await?;
                                
                                callback(7 + 52 * 1000, "foo_7[52]", reg.into());
                            
                                
                                let reg = self.foo_7(53).read_async().await?;
                                
                                callback(7 + 53 * 1000, "foo_7[53]", reg.into());
                            
                                
                                let reg = self.foo_7(54).read_async().await?;
                                
                                callback(7 + 54 * 1000, "foo_7[54]", reg.into());
                            
                                
                                let reg = self.foo_7(55).read_async().await?;
                                
                                callback(7 + 55 * 1000, "foo_7[55]", reg.into());
                            
                                
                                let reg = self.foo_7(56).read_async().await?;
                                
                                callback(7 + 56 * 1000, "foo_7[56]", reg.into());
                            
                                
                                let reg = self.foo_7(57).read_async().await?;
                                
                                callback(7 + 57 * 1000, "foo_7[57]", reg.into());
                            
                                
                                let reg = self.foo_7(58).read_async().await?;
                                
                                callback(7 + 58 * 1000, "foo_7[58]", reg.into());
                            
                                
                                let reg = self.foo_7(59).read_async().await?;
                                
                                callback(7 + 59 * 1000, "foo_7[59]", reg.into());
                            
                                
                                let reg = self.foo_7(60).read_async().await?;
                                
                                callback(7 + 60 * 1000, "foo_7[60]", reg.into());
                            
                                
                                let reg = self.foo_7(61).read_async().await?;
                                
                                callback(7 + 61 * 1000, "foo_7[61]", reg.into());
                            
                                
                                let reg = self.foo_7(62).read_async().await?;
                                
                                callback(7 + 62 * 1000, "foo_7[62]", reg.into());
                            
                                
                                let reg = self.foo_7(63).read_async().await?;
                                
                                callback(7 + 63 * 1000, "foo_7[63]", reg.into());
                            
                                
                                let reg = self.foo_7(64).read_async().await?;
                                
                                callback(7 + 64 * 1000, "foo_7[64]", reg.into());
                            
                                
                                let reg = self.foo_7(65).read_async().await?;
                                
                                callback(7 + 65 * 1000, "foo_7[65]", reg.into());
                            
                                
                                let reg = self.foo_7(66).read_async().await?;
                                
                                callback(7 + 66 * 1000, "foo_7[66]", reg.into());
                            
                                
                                let reg = self.foo_7(67).read_async().await?;
                                
                                callback(7 + 67 * 1000, "foo_7[67]", reg.into());
                            
                                
                                let reg = self.foo_7(68).read_async().await?;
                                
                                callback(7 + 68 * 1000, "foo_7[68]", reg.into());
                            
                                
                                let reg = self.foo_7(69).read_async().await?;
                                
                                callback(7 + 69 * 1000, "foo_7[69]", reg.into());
                            
                                
                                let reg = self.foo_7(70).read_async().await?;
                                
                                callback(7 + 70 * 1000, "foo_7[70]", reg.into());
                            
                                
                                let reg = self.foo_7(71).read_async().await?;
                                
                                callback(7 + 71 * 1000, "foo_7[71]", reg.into());
                            
                                
                                let reg = self.foo_7(72).read_async().await?;
                                
                                callback(7 + 72 * 1000, "foo_7[72]", reg.into());
                            
                                
                                let reg = self.foo_7(73).read_async().await?;
                                
                                callback(7 + 73 * 1000, "foo_7[73]", reg.into());
                            
                                
                                let reg = self.foo_7(74).read_async().await?;
                                
                                callback(7 + 74 * 1000, "foo_7[74]", reg.into());
                            
                                
                                let reg = self.foo_7(75).read_async().await?;
                                
                                callback(7 + 75 * 1000, "foo_7[75]", reg.into());
                            
                                
                                let reg = self.foo_7(76).read_async().await?;
                                
                                callback(7 + 76 * 1000, "foo_7[76]", reg.into());
                            
                                
                                let reg = self.foo_7(77).read_async().await?;
                                
                                callback(7 + 77 * 1000, "foo_7[77]", reg.into());
                            
                                
                                let reg = self.foo_7(78).read_async().await?;
                                
                                callback(7 + 78 * 1000, "foo_7[78]", reg.into());
                            
                                
                                let reg = self.foo_7(79).read_async().await?;
                                
                                callback(7 + 79 * 1000, "foo_7[79]", reg.into());
                            
                                
                                let reg = self.foo_7(80).read_async().await?;
                                
                                callback(7 + 80 * 1000, "foo_7[80]", reg.into());
                            
                                
                                let reg = self.foo_7(81).read_async().await?;
                                
                                callback(7 + 81 * 1000, "foo_7[81]", reg.into());
                            
                                
                                let reg = self.foo_7(82).read_async().await?;
                                
                                callback(7 + 82 * 1000, "foo_7[82]", reg.into());
                            
                                
                                let reg = self.foo_7(83).read_async().await?;
                                
                                callback(7 + 83 * 1000, "foo_7[83]", reg.into());
                            
                                
                                let reg = self.foo_7(84).read_async().await?;
                                
                                callback(7 + 84 * 1000, "foo_7[84]", reg.into());
                            
                                
                                let reg = self.foo_7(85).read_async().await?;
                                
                                callback(7 + 85 * 1000, "foo_7[85]", reg.into());
                            
                                
                                let reg = self.foo_7(86).read_async().await?;
                                
                                callback(7 + 86 * 1000, "foo_7[86]", reg.into());
                            
                                
                                let reg = self.foo_7(87).read_async().await?;
                                
                                callback(7 + 87 * 1000, "foo_7[87]", reg.into());
                            
                                
                                let reg = self.foo_7(88).read_async().await?;
                                
                                callback(7 + 88 * 1000, "foo_7[88]", reg.into());
                            
                                
                                let reg = self.foo_7(89).read_async().await?;
                                
                                callback(7 + 89 * 1000, "foo_7[89]", reg.into());
                            
                                
                                let reg = self.foo_7(90).read_async().await?;
                                
                                callback(7 + 90 * 1000, "foo_7[90]", reg.into());
                            
                                
                                let reg = self.foo_7(91).read_async().await?;
                                
                                callback(7 + 91 * 1000, "foo_7[91]", reg.into());
                            
                                
                                let reg = self.foo_7(92).read_async().await?;
                                
                                callback(7 + 92 * 1000, "foo_7[92]", reg.into());
                            
                                
                                let reg = self.foo_7(93).read_async().await?;
                                
                                callback(7 + 93 * 1000, "foo_7[93]", reg.into());
                            
                                
                                let reg = self.foo_7(94).read_async().await?;
                                
                                callback(7 + 94 * 1000, "foo_7[94]", reg.into());
                            
                                
                                let reg = self.foo_7(95).read_async().await?;
                                
                                callback(7 + 95 * 1000, "foo_7[95]", reg.into());
                            
                                
                                let reg = self.foo_7(96).read_async().await?;
                                
                                callback(7 + 96 * 1000, "foo_7[96]", reg.into());
                            
                                
                                let reg = self.foo_7(97).read_async().await?;
                                
                                callback(7 + 97 * 1000, "foo_7[97]", reg.into());
                            
                                
                                let reg = self.foo_7(98).read_async().await?;
                                
                                callback(7 + 98 * 1000, "foo_7[98]", reg.into());
                            
                                
                                let reg = self.foo_7(99).read_async().await?;
                                
                                callback(7 + 99 * 1000, "foo_7[99]", reg.into());
                            
                        
                
            
        
            
                
                    
                            
                                
                                let reg = self.foo_8(0).read_async().await?;
                                
                                callback(8 + 0 * 1000, "foo_8[0]", reg.into());
                            
                                
                                let reg = self.foo_8(1).read_async().await?;
                                
                                callback(8 + 1 * 1000, "foo_8[1]", reg.into());
                            
                                
                                let reg = self.foo_8(2).read_async().await?;
                                
                                callback(8 + 2 * 1000, "foo_8[2]", reg.into());
                            
                                
                                let reg = self.foo_8(3).read_async().await?;
                                
                                callback(8 + 3 * 1000, "foo_8[3]", reg.into());
                            
                                
                                let reg = self.foo_8(4).read_async().await?;
                                
                                callback(8 + 4 * 1000, "foo_8[4]", reg.into());
                            
                                
                                let reg = self.foo_8(5).read_async().await?;
                                
                                callback(8 + 5 * 1000, "foo_8[5]", reg.into());
                            
                                
                                let reg = self.foo_8(6).read_async().await?;
                                
                                callback(8 + 6 * 1000, "foo_8[6]", reg.into());
                            
                                
                                let reg = self.foo_8(7).read_async().await?;
                                
                                callback(8 + 7 * 1000, "foo_8[7]", reg.into());
                            
                                
                                let reg = self.foo_8(8).read_async().await?;
                                
                                callback(8 + 8 * 1000, "foo_8[8]", reg.into());
                            
                                
                                let reg = self.foo_8(9).read_async().await?;
                                
                                callback(8 + 9 * 1000, "foo_8[9]", reg.into());
                            
                                
                                let reg = self.foo_8(10).read_async().await?;
                                
                                callback(8 + 10 * 1000, "foo_8[10]", reg.into());
                            
                                
                                let reg = self.foo_8(11).read_async().await?;
                                
                                callback(8 + 11 * 1000, "foo_8[11]", reg.into());
                            
                                
                                let reg = self.foo_8(12).read_async().await?;
                                
                                callback(8 + 12 * 1000, "foo_8[12]", reg.into());
                            
                                
                                let reg = self.foo_8(13).read_async().await?;
                                
                                callback(8 + 13 * 1000, "foo_8[13]", reg.into());
                            
                                
                                let reg = self.foo_8(14).read_async().await?;
                                
                                callback(8 + 14 * 1000, "foo_8[14]", reg.into());
                            
                                
                                let reg = self.foo_8(15).read_async().await?;
                                
                                callback(8 + 15 * 1000, "foo_8[15]", reg.into());
                            
                                
                                let reg = self.foo_8(16).read_async().await?;
                                
                                callback(8 + 16 * 1000, "foo_8[16]", reg.into());
                            
                                
                                let reg = self.foo_8(17).read_async().await?;
                                
                                callback(8 + 17 * 1000, "foo_8[17]", reg.into());
                            
                                
                                let reg = self.foo_8(18).read_async().await?;
                                
                                callback(8 + 18 * 1000, "foo_8[18]", reg.into());
                            
                                
                                let reg = self.foo_8(19).read_async().await?;
                                
                                callback(8 + 19 * 1000, "foo_8[19]", reg.into());
                            
                                
                                let reg = self.foo_8(20).read_async().await?;
                                
                                callback(8 + 20 * 1000, "foo_8[20]", reg.into());
                            
                                
                                let reg = self.foo_8(21).read_async().await?;
                                
                                callback(8 + 21 * 1000, "foo_8[21]", reg.into());
                            
                                
                                let reg = self.foo_8(22).read_async().await?;
                                
                                callback(8 + 22 * 1000, "foo_8[22]", reg.into());
                            
                                
                                let reg = self.foo_8(23).read_async().await?;
                                
                                callback(8 + 23 * 1000, "foo_8[23]", reg.into());
                            
                                
                                let reg = self.foo_8(24).read_async().await?;
                                
                                callback(8 + 24 * 1000, "foo_8[24]", reg.into());
                            
                                
                                let reg = self.foo_8(25).read_async().await?;
                                
                                callback(8 + 25 * 1000, "foo_8[25]", reg.into());
                            
                                
                                let reg = self.foo_8(26).read_async().await?;
                                
                                callback(8 + 26 * 1000, "foo_8[26]", reg.into());
                            
                                
                                let reg = self.foo_8(27).read_async().await?;
                                
                                callback(8 + 27 * 1000, "foo_8[27]", reg.into());
                            
                                
                                let reg = self.foo_8(28).read_async().await?;
                                
                                callback(8 + 28 * 1000, "foo_8[28]", reg.into());
                            
                                
                                let reg = self.foo_8(29).read_async().await?;
                                
                                callback(8 + 29 * 1000, "foo_8[29]", reg.into());
                            
                                
                                let reg = self.foo_8(30).read_async().await?;
                                
                                callback(8 + 30 * 1000, "foo_8[30]", reg.into());
                            
                                
                                let reg = self.foo_8(31).read_async().await?;
                                
                                callback(8 + 31 * 1000, "foo_8[31]", reg.into());
                            
                                
                                let reg = self.foo_8(32).read_async().await?;
                                
                                callback(8 + 32 * 1000, "foo_8[32]", reg.into());
                            
                                
                                let reg = self.foo_8(33).read_async().await?;
                                
                                callback(8 + 33 * 1000, "foo_8[33]", reg.into());
                            
                                
                                let reg = self.foo_8(34).read_async().await?;
                                
                                callback(8 + 34 * 1000, "foo_8[34]", reg.into());
                            
                                
                                let reg = self.foo_8(35).read_async().await?;
                                
                                callback(8 + 35 * 1000, "foo_8[35]", reg.into());
                            
                                
                                let reg = self.foo_8(36).read_async().await?;
                                
                                callback(8 + 36 * 1000, "foo_8[36]", reg.into());
                            
                                
                                let reg = self.foo_8(37).read_async().await?;
                                
                                callback(8 + 37 * 1000, "foo_8[37]", reg.into());
                            
                                
                                let reg = self.foo_8(38).read_async().await?;
                                
                                callback(8 + 38 * 1000, "foo_8[38]", reg.into());
                            
                                
                                let reg = self.foo_8(39).read_async().await?;
                                
                                callback(8 + 39 * 1000, "foo_8[39]", reg.into());
                            
                                
                                let reg = self.foo_8(40).read_async().await?;
                                
                                callback(8 + 40 * 1000, "foo_8[40]", reg.into());
                            
                                
                                let reg = self.foo_8(41).read_async().await?;
                                
                                callback(8 + 41 * 1000, "foo_8[41]", reg.into());
                            
                                
                                let reg = self.foo_8(42).read_async().await?;
                                
                                callback(8 + 42 * 1000, "foo_8[42]", reg.into());
                            
                                
                                let reg = self.foo_8(43).read_async().await?;
                                
                                callback(8 + 43 * 1000, "foo_8[43]", reg.into());
                            
                                
                                let reg = self.foo_8(44).read_async().await?;
                                
                                callback(8 + 44 * 1000, "foo_8[44]", reg.into());
                            
                                
                                let reg = self.foo_8(45).read_async().await?;
                                
                                callback(8 + 45 * 1000, "foo_8[45]", reg.into());
                            
                                
                                let reg = self.foo_8(46).read_async().await?;
                                
                                callback(8 + 46 * 1000, "foo_8[46]", reg.into());
                            
                                
                                let reg = self.foo_8(47).read_async().await?;
                                
                                callback(8 + 47 * 1000, "foo_8[47]", reg.into());
                            
                                
                                let reg = self.foo_8(48).read_async().await?;
                                
                                callback(8 + 48 * 1000, "foo_8[48]", reg.into());
                            
                                
                                let reg = self.foo_8(49).read_async().await?;
                                
                                callback(8 + 49 * 1000, "foo_8[49]", reg.into());
                            
                                
                                let reg = self.foo_8(50).read_async().await?;
                                
                                callback(8 + 50 * 1000, "foo_8[50]", reg.into());
                            
                                
                                let reg = self.foo_8(51).read_async().await?;
                                
                                callback(8 + 51 * 1000, "foo_8[51]", reg.into());
                            
                                
                                let reg = self.foo_8(52).read_async().await?;
                                
                                callback(8 + 52 * 1000, "foo_8[52]", reg.into());
                            
                                
                                let reg = self.foo_8(53).read_async().await?;
                                
                                callback(8 + 53 * 1000, "foo_8[53]", reg.into());
                            
                                
                                let reg = self.foo_8(54).read_async().await?;
                                
                                callback(8 + 54 * 1000, "foo_8[54]", reg.into());
                            
                                
                                let reg = self.foo_8(55).read_async().await?;
                                
                                callback(8 + 55 * 1000, "foo_8[55]", reg.into());
                            
                                
                                let reg = self.foo_8(56).read_async().await?;
                                
                                callback(8 + 56 * 1000, "foo_8[56]", reg.into());
                            
                                
                                let reg = self.foo_8(57).read_async().await?;
                                
                                callback(8 + 57 * 1000, "foo_8[57]", reg.into());
                            
                                
                                let reg = self.foo_8(58).read_async().await?;
                                
                                callback(8 + 58 * 1000, "foo_8[58]", reg.into());
                            
                                
                                let reg = self.foo_8(59).read_async().await?;
                                
                                callback(8 + 59 * 1000, "foo_8[59]", reg.into());
                            
                                
                                let reg = self.foo_8(60).read_async().await?;
                                
                                callback(8 + 60 * 1000, "foo_8[60]", reg.into());
                            
                                
                                let reg = self.foo_8(61).read_async().await?;
                                
                                callback(8 + 61 * 1000, "foo_8[61]", reg.into());
                            
                                
                                let reg = self.foo_8(62).read_async().await?;
                                
                                callback(8 + 62 * 1000, "foo_8[62]", reg.into());
                            
                                
                                let reg = self.foo_8(63).read_async().await?;
                                
                                callback(8 + 63 * 1000, "foo_8[63]", reg.into());
                            
                                
                                let reg = self.foo_8(64).read_async().await?;
                                
                                callback(8 + 64 * 1000, "foo_8[64]", reg.into());
                            
                                
                                let reg = self.foo_8(65).read_async().await?;
                                
                                callback(8 + 65 * 1000, "foo_8[65]", reg.into());
                            
                                
                                let reg = self.foo_8(66).read_async().await?;
                                
                                callback(8 + 66 * 1000, "foo_8[66]", reg.into());
                            
                                
                                let reg = self.foo_8(67).read_async().await?;
                                
                                callback(8 + 67 * 1000, "foo_8[67]", reg.into());
                            
                                
                                let reg = self.foo_8(68).read_async().await?;
                                
                                callback(8 + 68 * 1000, "foo_8[68]", reg.into());
                            
                                
                                let reg = self.foo_8(69).read_async().await?;
                                
                                callback(8 + 69 * 1000, "foo_8[69]", reg.into());
                            
                                
                                let reg = self.foo_8(70).read_async().await?;
                                
                                callback(8 + 70 * 1000, "foo_8[70]", reg.into());
                            
                                
                                let reg = self.foo_8(71).read_async().await?;
                                
                                callback(8 + 71 * 1000, "foo_8[71]", reg.into());
                            
                                
                                let reg = self.foo_8(72).read_async().await?;
                                
                                callback(8 + 72 * 1000, "foo_8[72]", reg.into());
                            
                                
                                let reg = self.foo_8(73).read_async().await?;
                                
                                callback(8 + 73 * 1000, "foo_8[73]", reg.into());
                            
                                
                                let reg = self.foo_8(74).read_async().await?;
                                
                                callback(8 + 74 * 1000, "foo_8[74]", reg.into());
                            
                                
                                let reg = self.foo_8(75).read_async().await?;
                                
                                callback(8 + 75 * 1000, "foo_8[75]", reg.into());
                            
                                
                                let reg = self.foo_8(76).read_async().await?;
                                
                                callback(8 + 76 * 1000, "foo_8[76]", reg.into());
                            
                                
                                let reg = self.foo_8(77).read_async().await?;
                                
                                callback(8 + 77 * 1000, "foo_8[77]", reg.into());
                            
                                
                                let reg = self.foo_8(78).read_async().await?;
                                
                                callback(8 + 78 * 1000, "foo_8[78]", reg.into());
                            
                                
                                let reg = self.foo_8(79).read_async().await?;
                                
                                callback(8 + 79 * 1000, "foo_8[79]", reg.into());
                            
                                
                                let reg = self.foo_8(80).read_async().await?;
                                
                                callback(8 + 80 * 1000, "foo_8[80]", reg.into());
                            
                                
                                let reg = self.foo_8(81).read_async().await?;
                                
                                callback(8 + 81 * 1000, "foo_8[81]", reg.into());
                            
                                
                                let reg = self.foo_8(82).read_async().await?;
                                
                                callback(8 + 82 * 1000, "foo_8[82]", reg.into());
                            
                                
                                let reg = self.foo_8(83).read_async().await?;
                                
                                callback(8 + 83 * 1000, "foo_8[83]", reg.into());
                            
                                
                                let reg = self.foo_8(84).read_async().await?;
                                
                                callback(8 + 84 * 1000, "foo_8[84]", reg.into());
                            
                                
                                let reg = self.foo_8(85).read_async().await?;
                                
                                callback(8 + 85 * 1000, "foo_8[85]", reg.into());
                            
                                
                                let reg = self.foo_8(86).read_async().await?;
                                
                                callback(8 + 86 * 1000, "foo_8[86]", reg.into());
                            
                                
                                let reg = self.foo_8(87).read_async().await?;
                                
                                callback(8 + 87 * 1000, "foo_8[87]", reg.into());
                            
                                
                                let reg = self.foo_8(88).read_async().await?;
                                
                                callback(8 + 88 * 1000, "foo_8[88]", reg.into());
                            
                                
                                let reg = self.foo_8(89).read_async().await?;
                                
                                callback(8 + 89 * 1000, "foo_8[89]", reg.into());
                            
                                
                                let reg = self.foo_8(90).read_async().await?;
                                
                                callback(8 + 90 * 1000, "foo_8[90]", reg.into());
                            
                                
                                let reg = self.foo_8(91).read_async().await?;
                                
                                callback(8 + 91 * 1000, "foo_8[91]", reg.into());
                            
                                
                                let reg = self.foo_8(92).read_async().await?;
                                
                                callback(8 + 92 * 1000, "foo_8[92]", reg.into());
                            
                                
                                let reg = self.foo_8(93).read_async().await?;
                                
                                callback(8 + 93 * 1000, "foo_8[93]", reg.into());
                            
                                
                                let reg = self.foo_8(94).read_async().await?;
                                
                                callback(8 + 94 * 1000, "foo_8[94]", reg.into());
                            
                                
                                let reg = self.foo_8(95).read_async().await?;
                                
                                callback(8 + 95 * 1000, "foo_8[95]", reg.into());
                            
                                
                                let reg = self.foo_8(96).read_async().await?;
                                
                                callback(8 + 96 * 1000, "foo_8[96]", reg.into());
                            
                                
                                let reg = self.foo_8(97).read_async().await?;
                                
                                callback(8 + 97 * 1000, "foo_8[97]", reg.into());
                            
                                
                                let reg = self.foo_8(98).read_async().await?;
                                
                                callback(8 + 98 * 1000, "foo_8[98]", reg.into());
                            
                                
                                let reg = self.foo_8(99).read_async().await?;
                                
                                callback(8 + 99 * 1000, "foo_8[99]", reg.into());
                            
                        
                
            
        
            
                
                    
                            
                                
                                let reg = self.foo_9(0).read_async().await?;
                                
                                callback(9 + 0 * 1000, "foo_9[0]", reg.into());
                            
                                
                                let reg = self.foo_9(1).read_async().await?;
                                
                                callback(9 + 1 * 1000, "foo_9[1]", reg.into());
                            
                                
                                let reg = self.foo_9(2).read_async().await?;
                                
                                callback(9 + 2 * 1000, "foo_9[2]", reg.into());
                            
                                
                                let reg = self.foo_9(3).read_async().await?;
                                
                                callback(9 + 3 * 1000, "foo_9[3]", reg.into());
                            
                                
                                let reg = self.foo_9(4).read_async().await?;
                                
                                callback(9 + 4 * 1000, "foo_9[4]", reg.into());
                            
                                
                                let reg = self.foo_9(5).read_async().await?;
                                
                                callback(9 + 5 * 1000, "foo_9[5]", reg.into());
                            
                                
                                let reg = self.foo_9(6).read_async().await?;
                                
                                callback(9 + 6 * 1000, "foo_9[6]", reg.into());
                            
                                
                                let reg = self.foo_9(7).read_async().await?;
                                
                                callback(9 + 7 * 1000, "foo_9[7]", reg.into());
                            
                                
                                let reg = self.foo_9(8).read_async().await?;
                                
                                callback(9 + 8 * 1000, "foo_9[8]", reg.into());
                            
                                
                                let reg = self.foo_9(9).read_async().await?;
                                
                                callback(9 + 9 * 1000, "foo_9[9]", reg.into());
                            
                                
                                let reg = self.foo_9(10).read_async().await?;
                                
                                callback(9 + 10 * 1000, "foo_9[10]", reg.into());
                            
                                
                                let reg = self.foo_9(11).read_async().await?;
                                
                                callback(9 + 11 * 1000, "foo_9[11]", reg.into());
                            
                                
                                let reg = self.foo_9(12).read_async().await?;
                                
                                callback(9 + 12 * 1000, "foo_9[12]", reg.into());
                            
                                
                                let reg = self.foo_9(13).read_async().await?;
                                
                                callback(9 + 13 * 1000, "foo_9[13]", reg.into());
                            
                                
                                let reg = self.foo_9(14).read_async().await?;
                                
                                callback(9 + 14 * 1000, "foo_9[14]", reg.into());
                            
                                
                                let reg = self.foo_9(15).read_async().await?;
                                
                                callback(9 + 15 * 1000, "foo_9[15]", reg.into());
                            
                                
                                let reg = self.foo_9(16).read_async().await?;
                                
                                callback(9 + 16 * 1000, "foo_9[16]", reg.into());
                            
                                
                                let reg = self.foo_9(17).read_async().await?;
                                
                                callback(9 + 17 * 1000, "foo_9[17]", reg.into());
                            
                                
                                let reg = self.foo_9(18).read_async().await?;
                                
                                callback(9 + 18 * 1000, "foo_9[18]", reg.into());
                            
                                
                                let reg = self.foo_9(19).read_async().await?;
                                
                                callback(9 + 19 * 1000, "foo_9[19]", reg.into());
                            
                                
                                let reg = self.foo_9(20).read_async().await?;
                                
                                callback(9 + 20 * 1000, "foo_9[20]", reg.into());
                            
                                
                                let reg = self.foo_9(21).read_async().await?;
                                
                                callback(9 + 21 * 1000, "foo_9[21]", reg.into());
                            
                                
                                let reg = self.foo_9(22).read_async().await?;
                                
                                callback(9 + 22 * 1000, "foo_9[22]", reg.into());
                            
                                
                                let reg = self.foo_9(23).read_async().await?;
                                
                                callback(9 + 23 * 1000, "foo_9[23]", reg.into());
                            
                                
                                let reg = self.foo_9(24).read_async().await?;
                                
                                callback(9 + 24 * 1000, "foo_9[24]", reg.into());
                            
                                
                                let reg = self.foo_9(25).read_async().await?;
                                
                                callback(9 + 25 * 1000, "foo_9[25]", reg.into());
                            
                                
                                let reg = self.foo_9(26).read_async().await?;
                                
                                callback(9 + 26 * 1000, "foo_9[26]", reg.into());
                            
                                
                                let reg = self.foo_9(27).read_async().await?;
                                
                                callback(9 + 27 * 1000, "foo_9[27]", reg.into());
                            
                                
                                let reg = self.foo_9(28).read_async().await?;
                                
                                callback(9 + 28 * 1000, "foo_9[28]", reg.into());
                            
                                
                                let reg = self.foo_9(29).read_async().await?;
                                
                                callback(9 + 29 * 1000, "foo_9[29]", reg.into());
                            
                                
                                let reg = self.foo_9(30).read_async().await?;
                                
                                callback(9 + 30 * 1000, "foo_9[30]", reg.into());
                            
                                
                                let reg = self.foo_9(31).read_async().await?;
                                
                                callback(9 + 31 * 1000, "foo_9[31]", reg.into());
                            
                                
                                let reg = self.foo_9(32).read_async().await?;
                                
                                callback(9 + 32 * 1000, "foo_9[32]", reg.into());
                            
                                
                                let reg = self.foo_9(33).read_async().await?;
                                
                                callback(9 + 33 * 1000, "foo_9[33]", reg.into());
                            
                                
                                let reg = self.foo_9(34).read_async().await?;
                                
                                callback(9 + 34 * 1000, "foo_9[34]", reg.into());
                            
                                
                                let reg = self.foo_9(35).read_async().await?;
                                
                                callback(9 + 35 * 1000, "foo_9[35]", reg.into());
                            
                                
                                let reg = self.foo_9(36).read_async().await?;
                                
                                callback(9 + 36 * 1000, "foo_9[36]", reg.into());
                            
                                
                                let reg = self.foo_9(37).read_async().await?;
                                
                                callback(9 + 37 * 1000, "foo_9[37]", reg.into());
                            
                                
                                let reg = self.foo_9(38).read_async().await?;
                                
                                callback(9 + 38 * 1000, "foo_9[38]", reg.into());
                            
                                
                                let reg = self.foo_9(39).read_async().await?;
                                
                                callback(9 + 39 * 1000, "foo_9[39]", reg.into());
                            
                                
                                let reg = self.foo_9(40).read_async().await?;
                                
                                callback(9 + 40 * 1000, "foo_9[40]", reg.into());
                            
                                
                                let reg = self.foo_9(41).read_async().await?;
                                
                                callback(9 + 41 * 1000, "foo_9[41]", reg.into());
                            
                                
                                let reg = self.foo_9(42).read_async().await?;
                                
                                callback(9 + 42 * 1000, "foo_9[42]", reg.into());
                            
                                
                                let reg = self.foo_9(43).read_async().await?;
                                
                                callback(9 + 43 * 1000, "foo_9[43]", reg.into());
                            
                                
                                let reg = self.foo_9(44).read_async().await?;
                                
                                callback(9 + 44 * 1000, "foo_9[44]", reg.into());
                            
                                
                                let reg = self.foo_9(45).read_async().await?;
                                
                                callback(9 + 45 * 1000, "foo_9[45]", reg.into());
                            
                                
                                let reg = self.foo_9(46).read_async().await?;
                                
                                callback(9 + 46 * 1000, "foo_9[46]", reg.into());
                            
                                
                                let reg = self.foo_9(47).read_async().await?;
                                
                                callback(9 + 47 * 1000, "foo_9[47]", reg.into());
                            
                                
                                let reg = self.foo_9(48).read_async().await?;
                                
                                callback(9 + 48 * 1000, "foo_9[48]", reg.into());
                            
                                
                                let reg = self.foo_9(49).read_async().await?;
                                
                                callback(9 + 49 * 1000, "foo_9[49]", reg.into());
                            
                                
                                let reg = self.foo_9(50).read_async().await?;
                                
                                callback(9 + 50 * 1000, "foo_9[50]", reg.into());
                            
                                
                                let reg = self.foo_9(51).read_async().await?;
                                
                                callback(9 + 51 * 1000, "foo_9[51]", reg.into());
                            
                                
                                let reg = self.foo_9(52).read_async().await?;
                                
                                callback(9 + 52 * 1000, "foo_9[52]", reg.into());
                            
                                
                                let reg = self.foo_9(53).read_async().await?;
                                
                                callback(9 + 53 * 1000, "foo_9[53]", reg.into());
                            
                                
                                let reg = self.foo_9(54).read_async().await?;
                                
                                callback(9 + 54 * 1000, "foo_9[54]", reg.into());
                            
                                
                                let reg = self.foo_9(55).read_async().await?;
                                
                                callback(9 + 55 * 1000, "foo_9[55]", reg.into());
                            
                                
                                let reg = self.foo_9(56).read_async().await?;
                                
                                callback(9 + 56 * 1000, "foo_9[56]", reg.into());
                            
                                
                                let reg = self.foo_9(57).read_async().await?;
                                
                                callback(9 + 57 * 1000, "foo_9[57]", reg.into());
                            
                                
                                let reg = self.foo_9(58).read_async().await?;
                                
                                callback(9 + 58 * 1000, "foo_9[58]", reg.into());
                            
                                
                                let reg = self.foo_9(59).read_async().await?;
                                
                                callback(9 + 59 * 1000, "foo_9[59]", reg.into());
                            
                                
                                let reg = self.foo_9(60).read_async().await?;
                                
                                callback(9 + 60 * 1000, "foo_9[60]", reg.into());
                            
                                
                                let reg = self.foo_9(61).read_async().await?;
                                
                                callback(9 + 61 * 1000, "foo_9[61]", reg.into());
                            
                                
                                let reg = self.foo_9(62).read_async().await?;
                                
                                callback(9 + 62 * 1000, "foo_9[62]", reg.into());
                            
                                
                                let reg = self.foo_9(63).read_async().await?;
                                
                                callback(9 + 63 * 1000, "foo_9[63]", reg.into());
                            
                                
                                let reg = self.foo_9(64).read_async().await?;
                                
                                callback(9 + 64 * 1000, "foo_9[64]", reg.into());
                            
                                
                                let reg = self.foo_9(65).read_async().await?;
                                
                                callback(9 + 65 * 1000, "foo_9[65]", reg.into());
                            
                                
                                let reg = self.foo_9(66).read_async().await?;
                                
                                callback(9 + 66 * 1000, "foo_9[66]", reg.into());
                            
                                
                                let reg = self.foo_9(67).read_async().await?;
                                
                                callback(9 + 67 * 1000, "foo_9[67]", reg.into());
                            
                                
                                let reg = self.foo_9(68).read_async().await?;
                                
                                callback(9 + 68 * 1000, "foo_9[68]", reg.into());
                            
                                
                                let reg = self.foo_9(69).read_async().await?;
                                
                                callback(9 + 69 * 1000, "foo_9[69]", reg.into());
                            
                                
                                let reg = self.foo_9(70).read_async().await?;
                                
                                callback(9 + 70 * 1000, "foo_9[70]", reg.into());
                            
                                
                                let reg = self.foo_9(71).read_async().await?;
                                
                                callback(9 + 71 * 1000, "foo_9[71]", reg.into());
                            
                                
                                let reg = self.foo_9(72).read_async().await?;
                                
                                callback(9 + 72 * 1000, "foo_9[72]", reg.into());
                            
                                
                                let reg = self.foo_9(73).read_async().await?;
                                
                                callback(9 + 73 * 1000, "foo_9[73]", reg.into());
                            
                                
                                let reg = self.foo_9(74).read_async().await?;
                                
                                callback(9 + 74 * 1000, "foo_9[74]", reg.into());
                            
                                
                                let reg = self.foo_9(75).read_async().await?;
                                
                                callback(9 + 75 * 1000, "foo_9[75]", reg.into());
                            
                                
                                let reg = self.foo_9(76).read_async().await?;
                                
                                callback(9 + 76 * 1000, "foo_9[76]", reg.into());
                            
                                
                                let reg = self.foo_9(77).read_async().await?;
                                
                                callback(9 + 77 * 1000, "foo_9[77]", reg.into());
                            
                                
                                let reg = self.foo_9(78).read_async().await?;
                                
                                callback(9 + 78 * 1000, "foo_9[78]", reg.into());
                            
                                
                                let reg = self.foo_9(79).read_async().await?;
                                
                                callback(9 + 79 * 1000, "foo_9[79]", reg.into());
                            
                                
                                let reg = self.foo_9(80).read_async().await?;
                                
                                callback(9 + 80 * 1000, "foo_9[80]", reg.into());
                            
                                
                                let reg = self.foo_9(81).read_async().await?;
                                
                                callback(9 + 81 * 1000, "foo_9[81]", reg.into());
                            
                                
                                let reg = self.foo_9(82).read_async().await?;
                                
                                callback(9 + 82 * 1000, "foo_9[82]", reg.into());
                            
                                
                                let reg = self.foo_9(83).read_async().await?;
                                
                                callback(9 + 83 * 1000, "foo_9[83]", reg.into());
                            
                                
                                let reg = self.foo_9(84).read_async().await?;
                                
                                callback(9 + 84 * 1000, "foo_9[84]", reg.into());
                            
                                
                                let reg = self.foo_9(85).read_async().await?;
                                
                                callback(9 + 85 * 1000, "foo_9[85]", reg.into());
                            
                                
                                let reg = self.foo_9(86).read_async().await?;
                                
                                callback(9 + 86 * 1000, "foo_9[86]", reg.into());
                            
                                
                                let reg = self.foo_9(87).read_async().await?;
                                
                                callback(9 + 87 * 1000, "foo_9[87]", reg.into());
                            
                                
                                let reg = self.foo_9(88).read_async().await?;
                                
                                callback(9 + 88 * 1000, "foo_9[88]", reg.into());
                            
                                
                                let reg = self.foo_9(89).read_async().await?;
                                
                                callback(9 + 89 * 1000, "foo_9[89]", reg.into());
                            
                                
                                let reg = self.foo_9(90).read_async().await?;
                                
                                callback(9 + 90 * 1000, "foo_9[90]", reg.into());
                            
                                
                                let reg = self.foo_9(91).read_async().await?;
                                
                                callback(9 + 91 * 1000, "foo_9[91]", reg.into());
                            
                                
                                let reg = self.foo_9(92).read_async().await?;
                                
                                callback(9 + 92 * 1000, "foo_9[92]", reg.into());
                            
                                
                                let reg = self.foo_9(93).read_async().await?;
                                
                                callback(9 + 93 * 1000, "foo_9[93]", reg.into());
                            
                                
                                let reg = self.foo_9(94).read_async().await?;
                                
                                callback(9 + 94 * 1000, "foo_9[94]", reg.into());
                            
                                
                                let reg = self.foo_9(95).read_async().await?;
                                
                                callback(9 + 95 * 1000, "foo_9[95]", reg.into());
                            
                                
                                let reg = self.foo_9(96).read_async().await?;
                                
                                callback(9 + 96 * 1000, "foo_9[96]", reg.into());
                            
                                
                                let reg = self.foo_9(97).read_async().await?;
                                
                                callback(9 + 97 * 1000, "foo_9[97]", reg.into());
                            
                                
                                let reg = self.foo_9(98).read_async().await?;
                                
                                callback(9 + 98 * 1000, "foo_9[98]", reg.into());
                            
                                
                                let reg = self.foo_9(99).read_async().await?;
                                
                                callback(9 + 99 * 1000, "foo_9[99]", reg.into());
                            
                        
                
            
        
            
                
                    
                            
                                
                                let reg = self.foo_10(0).read_async().await?;
                                
                                callback(10 + 0 * 1000, "foo_10[0]", reg.into());
                            
                                
                                let reg = self.foo_10(1).read_async().await?;
                                
                                callback(10 + 1 * 1000, "foo_10[1]", reg.into());
                            
                                
                                let reg = self.foo_10(2).read_async().await?;
                                
                                callback(10 + 2 * 1000, "foo_10[2]", reg.into());
                            
                                
                                let reg = self.foo_10(3).read_async().await?;
                                
                                callback(10 + 3 * 1000, "foo_10[3]", reg.into());
                            
                                
                                let reg = self.foo_10(4).read_async().await?;
                                
                                callback(10 + 4 * 1000, "foo_10[4]", reg.into());
                            
                                
                                let reg = self.foo_10(5).read_async().await?;
                                
                                callback(10 + 5 * 1000, "foo_10[5]", reg.into());
                            
                                
                                let reg = self.foo_10(6).read_async().await?;
                                
                                callback(10 + 6 * 1000, "foo_10[6]", reg.into());
                            
                                
                                let reg = self.foo_10(7).read_async().await?;
                                
                                callback(10 + 7 * 1000, "foo_10[7]", reg.into());
                            
                                
                                let reg = self.foo_10(8).read_async().await?;
                                
                                callback(10 + 8 * 1000, "foo_10[8]", reg.into());
                            
                                
                                let reg = self.foo_10(9).read_async().await?;
                                
                                callback(10 + 9 * 1000, "foo_10[9]", reg.into());
                            
                                
                                let reg = self.foo_10(10).read_async().await?;
                                
                                callback(10 + 10 * 1000, "foo_10[10]", reg.into());
                            
                                
                                let reg = self.foo_10(11).read_async().await?;
                                
                                callback(10 + 11 * 1000, "foo_10[11]", reg.into());
                            
                                
                                let reg = self.foo_10(12).read_async().await?;
                                
                                callback(10 + 12 * 1000, "foo_10[12]", reg.into());
                            
                                
                                let reg = self.foo_10(13).read_async().await?;
                                
                                callback(10 + 13 * 1000, "foo_10[13]", reg.into());
                            
                                
                                let reg = self.foo_10(14).read_async().await?;
                                
                                callback(10 + 14 * 1000, "foo_10[14]", reg.into());
                            
                                
                                let reg = self.foo_10(15).read_async().await?;
                                
                                callback(10 + 15 * 1000, "foo_10[15]", reg.into());
                            
                                
                                let reg = self.foo_10(16).read_async().await?;
                                
                                callback(10 + 16 * 1000, "foo_10[16]", reg.into());
                            
                                
                                let reg = self.foo_10(17).read_async().await?;
                                
                                callback(10 + 17 * 1000, "foo_10[17]", reg.into());
                            
                                
                                let reg = self.foo_10(18).read_async().await?;
                                
                                callback(10 + 18 * 1000, "foo_10[18]", reg.into());
                            
                                
                                let reg = self.foo_10(19).read_async().await?;
                                
                                callback(10 + 19 * 1000, "foo_10[19]", reg.into());
                            
                                
                                let reg = self.foo_10(20).read_async().await?;
                                
                                callback(10 + 20 * 1000, "foo_10[20]", reg.into());
                            
                                
                                let reg = self.foo_10(21).read_async().await?;
                                
                                callback(10 + 21 * 1000, "foo_10[21]", reg.into());
                            
                                
                                let reg = self.foo_10(22).read_async().await?;
                                
                                callback(10 + 22 * 1000, "foo_10[22]", reg.into());
                            
                                
                                let reg = self.foo_10(23).read_async().await?;
                                
                                callback(10 + 23 * 1000, "foo_10[23]", reg.into());
                            
                                
                                let reg = self.foo_10(24).read_async().await?;
                                
                                callback(10 + 24 * 1000, "foo_10[24]", reg.into());
                            
                                
                                let reg = self.foo_10(25).read_async().await?;
                                
                                callback(10 + 25 * 1000, "foo_10[25]", reg.into());
                            
                                
                                let reg = self.foo_10(26).read_async().await?;
                                
                                callback(10 + 26 * 1000, "foo_10[26]", reg.into());
                            
                                
                                let reg = self.foo_10(27).read_async().await?;
                                
                                callback(10 + 27 * 1000, "foo_10[27]", reg.into());
                            
                                
                                let reg = self.foo_10(28).read_async().await?;
                                
                                callback(10 + 28 * 1000, "foo_10[28]", reg.into());
                            
                                
                                let reg = self.foo_10(29).read_async().await?;
                                
                                callback(10 + 29 * 1000, "foo_10[29]", reg.into());
                            
                                
                                let reg = self.foo_10(30).read_async().await?;
                                
                                callback(10 + 30 * 1000, "foo_10[30]", reg.into());
                            
                                
                                let reg = self.foo_10(31).read_async().await?;
                                
                                callback(10 + 31 * 1000, "foo_10[31]", reg.into());
                            
                                
                                let reg = self.foo_10(32).read_async().await?;
                                
                                callback(10 + 32 * 1000, "foo_10[32]", reg.into());
                            
                                
                                let reg = self.foo_10(33).read_async().await?;
                                
                                callback(10 + 33 * 1000, "foo_10[33]", reg.into());
                            
                                
                                let reg = self.foo_10(34).read_async().await?;
                                
                                callback(10 + 34 * 1000, "foo_10[34]", reg.into());
                            
                                
                                let reg = self.foo_10(35).read_async().await?;
                                
                                callback(10 + 35 * 1000, "foo_10[35]", reg.into());
                            
                                
                                let reg = self.foo_10(36).read_async().await?;
                                
                                callback(10 + 36 * 1000, "foo_10[36]", reg.into());
                            
                                
                                let reg = self.foo_10(37).read_async().await?;
                                
                                callback(10 + 37 * 1000, "foo_10[37]", reg.into());
                            
                                
                                let reg = self.foo_10(38).read_async().await?;
                                
                                callback(10 + 38 * 1000, "foo_10[38]", reg.into());
                            
                                
                                let reg = self.foo_10(39).read_async().await?;
                                
                                callback(10 + 39 * 1000, "foo_10[39]", reg.into());
                            
                                
                                let reg = self.foo_10(40).read_async().await?;
                                
                                callback(10 + 40 * 1000, "foo_10[40]", reg.into());
                            
                                
                                let reg = self.foo_10(41).read_async().await?;
                                
                                callback(10 + 41 * 1000, "foo_10[41]", reg.into());
                            
                                
                                let reg = self.foo_10(42).read_async().await?;
                                
                                callback(10 + 42 * 1000, "foo_10[42]", reg.into());
                            
                                
                                let reg = self.foo_10(43).read_async().await?;
                                
                                callback(10 + 43 * 1000, "foo_10[43]", reg.into());
                            
                                
                                let reg = self.foo_10(44).read_async().await?;
                                
                                callback(10 + 44 * 1000, "foo_10[44]", reg.into());
                            
                                
                                let reg = self.foo_10(45).read_async().await?;
                                
                                callback(10 + 45 * 1000, "foo_10[45]", reg.into());
                            
                                
                                let reg = self.foo_10(46).read_async().await?;
                                
                                callback(10 + 46 * 1000, "foo_10[46]", reg.into());
                            
                                
                                let reg = self.foo_10(47).read_async().await?;
                                
                                callback(10 + 47 * 1000, "foo_10[47]", reg.into());
                            
                                
                                let reg = self.foo_10(48).read_async().await?;
                                
                                callback(10 + 48 * 1000, "foo_10[48]", reg.into());
                            
                                
                                let reg = self.foo_10(49).read_async().await?;
                                
                                callback(10 + 49 * 1000, "foo_10[49]", reg.into());
                            
                                
                                let reg = self.foo_10(50).read_async().await?;
                                
                                callback(10 + 50 * 1000, "foo_10[50]", reg.into());
                            
                                
                                let reg = self.foo_10(51).read_async().await?;
                                
                                callback(10 + 51 * 1000, "foo_10[51]", reg.into());
                            
                                
                                let reg = self.foo_10(52).read_async().await?;
                                
                                callback(10 + 52 * 1000, "foo_10[52]", reg.into());
                            
                                
                                let reg = self.foo_10(53).read_async().await?;
                                
                                callback(10 + 53 * 1000, "foo_10[53]", reg.into());
                            
                                
                                let reg = self.foo_10(54).read_async().await?;
                                
                                callback(10 + 54 * 1000, "foo_10[54]", reg.into());
                            
                                
                                let reg = self.foo_10(55).read_async().await?;
                                
                                callback(10 + 55 * 1000, "foo_10[55]", reg.into());
                            
                                
                                let reg = self.foo_10(56).read_async().await?;
                                
                                callback(10 + 56 * 1000, "foo_10[56]", reg.into());
                            
                                
                                let reg = self.foo_10(57).read_async().await?;
                                
                                callback(10 + 57 * 1000, "foo_10[57]", reg.into());
                            
                                
                                let reg = self.foo_10(58).read_async().await?;
                                
                                callback(10 + 58 * 1000, "foo_10[58]", reg.into());
                            
                                
                                let reg = self.foo_10(59).read_async().await?;
                                
                                callback(10 + 59 * 1000, "foo_10[59]", reg.into());
                            
                                
                                let reg = self.foo_10(60).read_async().await?;
                                
                                callback(10 + 60 * 1000, "foo_10[60]", reg.into());
                            
                                
                                let reg = self.foo_10(61).read_async().await?;
                                
                                callback(10 + 61 * 1000, "foo_10[61]", reg.into());
                            
                                
                                let reg = self.foo_10(62).read_async().await?;
                                
                                callback(10 + 62 * 1000, "foo_10[62]", reg.into());
                            
                                
                                let reg = self.foo_10(63).read_async().await?;
                                
                                callback(10 + 63 * 1000, "foo_10[63]", reg.into());
                            
                                
                                let reg = self.foo_10(64).read_async().await?;
                                
                                callback(10 + 64 * 1000, "foo_10[64]", reg.into());
                            
                                
                                let reg = self.foo_10(65).read_async().await?;
                                
                                callback(10 + 65 * 1000, "foo_10[65]", reg.into());
                            
                                
                                let reg = self.foo_10(66).read_async().await?;
                                
                                callback(10 + 66 * 1000, "foo_10[66]", reg.into());
                            
                                
                                let reg = self.foo_10(67).read_async().await?;
                                
                                callback(10 + 67 * 1000, "foo_10[67]", reg.into());
                            
                                
                                let reg = self.foo_10(68).read_async().await?;
                                
                                callback(10 + 68 * 1000, "foo_10[68]", reg.into());
                            
                                
                                let reg = self.foo_10(69).read_async().await?;
                                
                                callback(10 + 69 * 1000, "foo_10[69]", reg.into());
                            
                                
                                let reg = self.foo_10(70).read_async().await?;
                                
                                callback(10 + 70 * 1000, "foo_10[70]", reg.into());
                            
                                
                                let reg = self.foo_10(71).read_async().await?;
                                
                                callback(10 + 71 * 1000, "foo_10[71]", reg.into());
                            
                                
                                let reg = self.foo_10(72).read_async().await?;
                                
                                callback(10 + 72 * 1000, "foo_10[72]", reg.into());
                            
                                
                                let reg = self.foo_10(73).read_async().await?;
                                
                                callback(10 + 73 * 1000, "foo_10[73]", reg.into());
                            
                                
                                let reg = self.foo_10(74).read_async().await?;
                                
                                callback(10 + 74 * 1000, "foo_10[74]", reg.into());
                            
                                
                                let reg = self.foo_10(75).read_async().await?;
                                
                                callback(10 + 75 * 1000, "foo_10[75]", reg.into());
                            
                                
                                let reg = self.foo_10(76).read_async().await?;
                                
                                callback(10 + 76 * 1000, "foo_10[76]", reg.into());
                            
                                
                                let reg = self.foo_10(77).read_async().await?;
                                
                                callback(10 + 77 * 1000, "foo_10[77]", reg.into());
                            
                                
                                let reg = self.foo_10(78).read_async().await?;
                                
                                callback(10 + 78 * 1000, "foo_10[78]", reg.into());
                            
                                
                                let reg = self.foo_10(79).read_async().await?;
                                
                                callback(10 + 79 * 1000, "foo_10[79]", reg.into());
                            
                                
                                let reg = self.foo_10(80).read_async().await?;
                                
                                callback(10 + 80 * 1000, "foo_10[80]", reg.into());
                            
                                
                                let reg = self.foo_10(81).read_async().await?;
                                
                                callback(10 + 81 * 1000, "foo_10[81]", reg.into());
                            
                                
                                let reg = self.foo_10(82).read_async().await?;
                                
                                callback(10 + 82 * 1000, "foo_10[82]", reg.into());
                            
                                
                                let reg = self.foo_10(83).read_async().await?;
                                
                                callback(10 + 83 * 1000, "foo_10[83]", reg.into());
                            
                                
                                let reg = self.foo_10(84).read_async().await?;
                                
                                callback(10 + 84 * 1000, "foo_10[84]", reg.into());
                            
                                
                                let reg = self.foo_10(85).read_async().await?;
                                
                                callback(10 + 85 * 1000, "foo_10[85]", reg.into());
                            
                                
                                let reg = self.foo_10(86).read_async().await?;
                                
                                callback(10 + 86 * 1000, "foo_10[86]", reg.into());
                            
                                
                                let reg = self.foo_10(87).read_async().await?;
                                
                                callback(10 + 87 * 1000, "foo_10[87]", reg.into());
                            
                                
                                let reg = self.foo_10(88).read_async().await?;
                                
                                callback(10 + 88 * 1000, "foo_10[88]", reg.into());
                            
                                
                                let reg = self.foo_10(89).read_async().await?;
                                
                                callback(10 + 89 * 1000, "foo_10[89]", reg.into());
                            
                                
                                let reg = self.foo_10(90).read_async().await?;
                                
                                callback(10 + 90 * 1000, "foo_10[90]", reg.into());
                            
                                
                                let reg = self.foo_10(91).read_async().await?;
                                
                                callback(10 + 91 * 1000, "foo_10[91]", reg.into());
                            
                                
                                let reg = self.foo_10(92).read_async().await?;
                                
                                callback(10 + 92 * 1000, "foo_10[92]", reg.into());
                            
                                
                                let reg = self.foo_10(93).read_async().await?;
                                
                                callback(10 + 93 * 1000, "foo_10[93]", reg.into());
                            
                                
                                let reg = self.foo_10(94).read_async().await?;
                                
                                callback(10 + 94 * 1000, "foo_10[94]", reg.into());
                            
                                
                                let reg = self.foo_10(95).read_async().await?;
                                
                                callback(10 + 95 * 1000, "foo_10[95]", reg.into());
                            
                                
                                let reg = self.foo_10(96).read_async().await?;
                                
                                callback(10 + 96 * 1000, "foo_10[96]", reg.into());
                            
                                
                                let reg = self.foo_10(97).read_async().await?;
                                
                                callback(10 + 97 * 1000, "foo_10[97]", reg.into());
                            
                                
                                let reg = self.foo_10(98).read_async().await?;
                                
                                callback(10 + 98 * 1000, "foo_10[98]", reg.into());
                            
                                
                                let reg = self.foo_10(99).read_async().await?;
                                
                                callback(10 + 99 * 1000, "foo_10[99]", reg.into());
                            
                        
                
            
        
            
                
                    
                            
                                
                                let reg = self.foo_11(0).read_async().await?;
                                
                                callback(11 + 0 * 1000, "foo_11[0]", reg.into());
                            
                                
                                let reg = self.foo_11(1).read_async().await?;
                                
                                callback(11 + 1 * 1000, "foo_11[1]", reg.into());
                            
                                
                                let reg = self.foo_11(2).read_async().await?;
                                
                                callback(11 + 2 * 1000, "foo_11[2]", reg.into());
                            
                                
                                let reg = self.foo_11(3).read_async().await?;
                                
                                callback(11 + 3 * 1000, "foo_11[3]", reg.into());
                            
                                
                                let reg = self.foo_11(4).read_async().await?;
                                
                                callback(11 + 4 * 1000, "foo_11[4]", reg.into());
                            
                                
                                let reg = self.foo_11(5).read_async().await?;
                                
                                callback(11 + 5 * 1000, "foo_11[5]", reg.into());
                            
                                
                                let reg = self.foo_11(6).read_async().await?;
                                
                                callback(11 + 6 * 1000, "foo_11[6]", reg.into());
                            
                                
                                let reg = self.foo_11(7).read_async().await?;
                                
                                callback(11 + 7 * 1000, "foo_11[7]", reg.into());
                            
                                
                                let reg = self.foo_11(8).read_async().await?;
                                
                                callback(11 + 8 * 1000, "foo_11[8]", reg.into());
                            
                                
                                let reg = self.foo_11(9).read_async().await?;
                                
                                callback(11 + 9 * 1000, "foo_11[9]", reg.into());
                            
                                
                                let reg = self.foo_11(10).read_async().await?;
                                
                                callback(11 + 10 * 1000, "foo_11[10]", reg.into());
                            
                                
                                let reg = self.foo_11(11).read_async().await?;
                                
                                callback(11 + 11 * 1000, "foo_11[11]", reg.into());
                            
                                
                                let reg = self.foo_11(12).read_async().await?;
                                
                                callback(11 + 12 * 1000, "foo_11[12]", reg.into());
                            
                                
                                let reg = self.foo_11(13).read_async().await?;
                                
                                callback(11 + 13 * 1000, "foo_11[13]", reg.into());
                            
                                
                                let reg = self.foo_11(14).read_async().await?;
                                
                                callback(11 + 14 * 1000, "foo_11[14]", reg.into());
                            
                                
                                let reg = self.foo_11(15).read_async().await?;
                                
                                callback(11 + 15 * 1000, "foo_11[15]", reg.into());
                            
                                
                                let reg = self.foo_11(16).read_async().await?;
                                
                                callback(11 + 16 * 1000, "foo_11[16]", reg.into());
                            
                                
                                let reg = self.foo_11(17).read_async().await?;
                                
                                callback(11 + 17 * 1000, "foo_11[17]", reg.into());
                            
                                
                                let reg = self.foo_11(18).read_async().await?;
                                
                                callback(11 + 18 * 1000, "foo_11[18]", reg.into());
                            
                                
                                let reg = self.foo_11(19).read_async().await?;
                                
                                callback(11 + 19 * 1000, "foo_11[19]", reg.into());
                            
                                
                                let reg = self.foo_11(20).read_async().await?;
                                
                                callback(11 + 20 * 1000, "foo_11[20]", reg.into());
                            
                                
                                let reg = self.foo_11(21).read_async().await?;
                                
                                callback(11 + 21 * 1000, "foo_11[21]", reg.into());
                            
                                
                                let reg = self.foo_11(22).read_async().await?;
                                
                                callback(11 + 22 * 1000, "foo_11[22]", reg.into());
                            
                                
                                let reg = self.foo_11(23).read_async().await?;
                                
                                callback(11 + 23 * 1000, "foo_11[23]", reg.into());
                            
                                
                                let reg = self.foo_11(24).read_async().await?;
                                
                                callback(11 + 24 * 1000, "foo_11[24]", reg.into());
                            
                                
                                let reg = self.foo_11(25).read_async().await?;
                                
                                callback(11 + 25 * 1000, "foo_11[25]", reg.into());
                            
                                
                                let reg = self.foo_11(26).read_async().await?;
                                
                                callback(11 + 26 * 1000, "foo_11[26]", reg.into());
                            
                                
                                let reg = self.foo_11(27).read_async().await?;
                                
                                callback(11 + 27 * 1000, "foo_11[27]", reg.into());
                            
                                
                                let reg = self.foo_11(28).read_async().await?;
                                
                                callback(11 + 28 * 1000, "foo_11[28]", reg.into());
                            
                                
                                let reg = self.foo_11(29).read_async().await?;
                                
                                callback(11 + 29 * 1000, "foo_11[29]", reg.into());
                            
                                
                                let reg = self.foo_11(30).read_async().await?;
                                
                                callback(11 + 30 * 1000, "foo_11[30]", reg.into());
                            
                                
                                let reg = self.foo_11(31).read_async().await?;
                                
                                callback(11 + 31 * 1000, "foo_11[31]", reg.into());
                            
                                
                                let reg = self.foo_11(32).read_async().await?;
                                
                                callback(11 + 32 * 1000, "foo_11[32]", reg.into());
                            
                                
                                let reg = self.foo_11(33).read_async().await?;
                                
                                callback(11 + 33 * 1000, "foo_11[33]", reg.into());
                            
                                
                                let reg = self.foo_11(34).read_async().await?;
                                
                                callback(11 + 34 * 1000, "foo_11[34]", reg.into());
                            
                                
                                let reg = self.foo_11(35).read_async().await?;
                                
                                callback(11 + 35 * 1000, "foo_11[35]", reg.into());
                            
                                
                                let reg = self.foo_11(36).read_async().await?;
                                
                                callback(11 + 36 * 1000, "foo_11[36]", reg.into());
                            
                                
                                let reg = self.foo_11(37).read_async().await?;
                                
                                callback(11 + 37 * 1000, "foo_11[37]", reg.into());
                            
                                
                                let reg = self.foo_11(38).read_async().await?;
                                
                                callback(11 + 38 * 1000, "foo_11[38]", reg.into());
                            
                                
                                let reg = self.foo_11(39).read_async().await?;
                                
                                callback(11 + 39 * 1000, "foo_11[39]", reg.into());
                            
                                
                                let reg = self.foo_11(40).read_async().await?;
                                
                                callback(11 + 40 * 1000, "foo_11[40]", reg.into());
                            
                                
                                let reg = self.foo_11(41).read_async().await?;
                                
                                callback(11 + 41 * 1000, "foo_11[41]", reg.into());
                            
                                
                                let reg = self.foo_11(42).read_async().await?;
                                
                                callback(11 + 42 * 1000, "foo_11[42]", reg.into());
                            
                                
                                let reg = self.foo_11(43).read_async().await?;
                                
                                callback(11 + 43 * 1000, "foo_11[43]", reg.into());
                            
                                
                                let reg = self.foo_11(44).read_async().await?;
                                
                                callback(11 + 44 * 1000, "foo_11[44]", reg.into());
                            
                                
                                let reg = self.foo_11(45).read_async().await?;
                                
                                callback(11 + 45 * 1000, "foo_11[45]", reg.into());
                            
                                
                                let reg = self.foo_11(46).read_async().await?;
                                
                                callback(11 + 46 * 1000, "foo_11[46]", reg.into());
                            
                                
                                let reg = self.foo_11(47).read_async().await?;
                                
                                callback(11 + 47 * 1000, "foo_11[47]", reg.into());
                            
                                
                                let reg = self.foo_11(48).read_async().await?;
                                
                                callback(11 + 48 * 1000, "foo_11[48]", reg.into());
                            
                                
                                let reg = self.foo_11(49).read_async().await?;
                                
                                callback(11 + 49 * 1000, "foo_11[49]", reg.into());
                            
                                
                                let reg = self.foo_11(50).read_async().await?;
                                
                                callback(11 + 50 * 1000, "foo_11[50]", reg.into());
                            
                                
                                let reg = self.foo_11(51).read_async().await?;
                                
                                callback(11 + 51 * 1000, "foo_11[51]", reg.into());
                            
                                
                                let reg = self.foo_11(52).read_async().await?;
                                
                                callback(11 + 52 * 1000, "foo_11[52]", reg.into());
                            
                                
                                let reg = self.foo_11(53).read_async().await?;
                                
                                callback(11 + 53 * 1000, "foo_11[53]", reg.into());
                            
                                
                                let reg = self.foo_11(54).read_async().await?;
                                
                                callback(11 + 54 * 1000, "foo_11[54]", reg.into());
                            
                                
                                let reg = self.foo_11(55).read_async().await?;
                                
                                callback(11 + 55 * 1000, "foo_11[55]", reg.into());
                            
                                
                                let reg = self.foo_11(56).read_async().await?;
                                
                                callback(11 + 56 * 1000, "foo_11[56]", reg.into());
                            
                                
                                let reg = self.foo_11(57).read_async().await?;
                                
                                callback(11 + 57 * 1000, "foo_11[57]", reg.into());
                            
                                
                                let reg = self.foo_11(58).read_async().await?;
                                
                                callback(11 + 58 * 1000, "foo_11[58]", reg.into());
                            
                                
                                let reg = self.foo_11(59).read_async().await?;
                                
                                callback(11 + 59 * 1000, "foo_11[59]", reg.into());
                            
                                
                                let reg = self.foo_11(60).read_async().await?;
                                
                                callback(11 + 60 * 1000, "foo_11[60]", reg.into());
                            
                                
                                let reg = self.foo_11(61).read_async().await?;
                                
                                callback(11 + 61 * 1000, "foo_11[61]", reg.into());
                            
                                
                                let reg = self.foo_11(62).read_async().await?;
                                
                                callback(11 + 62 * 1000, "foo_11[62]", reg.into());
                            
                                
                                let reg = self.foo_11(63).read_async().await?;
                                
                                callback(11 + 63 * 1000, "foo_11[63]", reg.into());
                            
                                
                                let reg = self.foo_11(64).read_async().await?;
                                
                                callback(11 + 64 * 1000, "foo_11[64]", reg.into());
                            
                                
                                let reg = self.foo_11(65).read_async().await?;
                                
                                callback(11 + 65 * 1000, "foo_11[65]", reg.into());
                            
                                
                                let reg = self.foo_11(66).read_async().await?;
                                
                                callback(11 + 66 * 1000, "foo_11[66]", reg.into());
                            
                                
                                let reg = self.foo_11(67).read_async().await?;
                                
                                callback(11 + 67 * 1000, "foo_11[67]", reg.into());
                            
                                
                                let reg = self.foo_11(68).read_async().await?;
                                
                                callback(11 + 68 * 1000, "foo_11[68]", reg.into());
                            
                                
                                let reg = self.foo_11(69).read_async().await?;
                                
                                callback(11 + 69 * 1000, "foo_11[69]", reg.into());
                            
                                
                                let reg = self.foo_11(70).read_async().await?;
                                
                                callback(11 + 70 * 1000, "foo_11[70]", reg.into());
                            
                                
                                let reg = self.foo_11(71).read_async().await?;
                                
                                callback(11 + 71 * 1000, "foo_11[71]", reg.into());
                            
                                
                                let reg = self.foo_11(72).read_async().await?;
                                
                                callback(11 + 72 * 1000, "foo_11[72]", reg.into());
                            
                                
                                let reg = self.foo_11(73).read_async().await?;
                                
                                callback(11 + 73 * 1000, "foo_11[73]", reg.into());
                            
                                
                                let reg = self.foo_11(74).read_async().await?;
                                
                                callback(11 + 74 * 1000, "foo_11[74]", reg.into());
                            
                                
                                let reg = self.foo_11(75).read_async().await?;
                                
                                callback(11 + 75 * 1000, "foo_11[75]", reg.into());
                            
                                
                                let reg = self.foo_11(76).read_async().await?;
                                
                                callback(11 + 76 * 1000, "foo_11[76]", reg.into());
                            
                                
                                let reg = self.foo_11(77).read_async().await?;
                                
                                callback(11 + 77 * 1000, "foo_11[77]", reg.into());
                            
                                
                                let reg = self.foo_11(78).read_async().await?;
                                
                                callback(11 + 78 * 1000, "foo_11[78]", reg.into());
                            
                                
                                let reg = self.foo_11(79).read_async().await?;
                                
                                callback(11 + 79 * 1000, "foo_11[79]", reg.into());
                            
                                
                                let reg = self.foo_11(80).read_async().await?;
                                
                                callback(11 + 80 * 1000, "foo_11[80]", reg.into());
                            
                                
                                let reg = self.foo_11(81).read_async().await?;
                                
                                callback(11 + 81 * 1000, "foo_11[81]", reg.into());
                            
                                
                                let reg = self.foo_11(82).read_async().await?;
                                
                                callback(11 + 82 * 1000, "foo_11[82]", reg.into());
                            
                                
                                let reg = self.foo_11(83).read_async().await?;
                                
                                callback(11 + 83 * 1000, "foo_11[83]", reg.into());
                            
                                
                                let reg = self.foo_11(84).read_async().await?;
                                
                                callback(11 + 84 * 1000, "foo_11[84]", reg.into());
                            
                                
                                let reg = self.foo_11(85).read_async().await?;
                                
                                callback(11 + 85 * 1000, "foo_11[85]", reg.into());
                            
                                
                                let reg = self.foo_11(86).read_async().await?;
                                
                                callback(11 + 86 * 1000, "foo_11[86]", reg.into());
                            
                                
                                let reg = self.foo_11(87).read_async().await?;
                                
                                callback(11 + 87 * 1000, "foo_11[87]", reg.into());
                            
                                
                                let reg = self.foo_11(88).read_async().await?;
                                
                                callback(11 + 88 * 1000, "foo_11[88]", reg.into());
                            
                                
                                let reg = self.foo_11(89).read_async().await?;
                                
                                callback(11 + 89 * 1000, "foo_11[89]", reg.into());
                            
                                
                                let reg = self.foo_11(90).read_async().await?;
                                
                                callback(11 + 90 * 1000, "foo_11[90]", reg.into());
                            
                                
                                let reg = self.foo_11(91).read_async().await?;
                                
                                callback(11 + 91 * 1000, "foo_11[91]", reg.into());
                            
                                
                                let reg = self.foo_11(92).read_async().await?;
                                
                                callback(11 + 92 * 1000, "foo_11[92]", reg.into());
                            
                                
                                let reg = self.foo_11(93).read_async().await?;
                                
                                callback(11 + 93 * 1000, "foo_11[93]", reg.into());
                            
                                
                                let reg = self.foo_11(94).read_async().await?;
                                
                                callback(11 + 94 * 1000, "foo_11[94]", reg.into());
                            
                                
                                let reg = self.foo_11(95).read_async().await?;
                                
                                callback(11 + 95 * 1000, "foo_11[95]", reg.into());
                            
                                
                                let reg = self.foo_11(96).read_async().await?;
                                
                                callback(11 + 96 * 1000, "foo_11[96]", reg.into());
                            
                                
                                let reg = self.foo_11(97).read_async().await?;
                                
                                callback(11 + 97 * 1000, "foo_11[97]", reg.into());
                            
                                
                                let reg = self.foo_11(98).read_async().await?;
                                
                                callback(11 + 98 * 1000, "foo_11[98]", reg.into());
                            
                                
                                let reg = self.foo_11(99).read_async().await?;
                                
                                callback(11 + 99 * 1000, "foo_11[99]", reg.into());
                            
                        
                
            
        

        Ok(())
    }

    
        
        
            ///
            /// Valid index range: 0..100
            
        
        pub fn foo_0(
            &mut self,
             index: usize
            
        ) -> 
         ::device_driver::RegisterOperation<'_, I, u32, field_sets::Foo0, ::device_driver::RW>
            
        {
            
                    let address = {
                        assert!(index < 100);
                        self.base_address + 0 + index as u32 * 1000
                    };
                

            
                    ::device_driver::RegisterOperation::<
                        '_,
                        I,
                        u32,
                        field_sets::Foo0,
                        ::device_driver::RW,
                    >::new(self.interface(), address as u32, field_sets::Foo0::new)
                
        }
    
        
        
            ///
            /// Valid index range: 0..100
            
        
        pub fn foo_1(
            &mut self,
             index: usize
            
        ) -> 
         ::device_driver::RegisterOperation<'_, I, u32, field_sets::Foo1, ::device_driver::RW>
            
        {
            
                    let address = {
                        assert!(index < 100);
                        self.base_address + 1 + index as u32 * 1000
                    };
                

            
                    ::device_driver::RegisterOperation::<
                        '_,
                        I,
                        u32,
                        field_sets::Foo1,
                        ::device_driver::RW,
                    >::new(self.interface(), address as u32, field_sets::Foo1::new)
                
        }
    
        
        
            ///
            /// Valid index range: 0..100
            
        
        pub fn foo_2(
            &mut self,
             index: usize
            
        ) -> 
         ::device_driver::RegisterOperation<'_, I, u32, field_sets::Foo2, ::device_driver::RW>
            
        {
            
                    let address = {
                        assert!(index < 100);
                        self.base_address + 2 + index as u32 * 1000
                    };
                

            
                    ::device_driver::RegisterOperation::<
                        '_,
                        I,
                        u32,
                        field_sets::Foo2,
                        ::device_driver::RW,
                    >::new(self.interface(), address as u32, field_sets::Foo2::new)
                
        }
    
        
        
            ///
            /// Valid index range: 0..100
            
        
        pub fn foo_3(
            &mut self,
             index: usize
            
        ) -> 
         ::device_driver::RegisterOperation<'_, I, u32, field_sets::Foo3, ::device_driver::RW>
            
        {
            
                    let address = {
                        assert!(index < 100);
                        self.base_address + 3 + index as u32 * 1000
                    };
                

            
                    ::device_driver::RegisterOperation::<
                        '_,
                        I,
                        u32,
                        field_sets::Foo3,
                        ::device_driver::RW,
                    >::new(self.interface(), address as u32, field_sets::Foo3::new)
                
        }
    
        
        
            ///
            /// Valid index range: 0..100
            
        
        pub fn foo_4(
            &mut self,
             index: usize
            
        ) -> 
         ::device_driver::RegisterOperation<'_, I, u32, field_sets::Foo4, ::device_driver::RW>
            
        {
            
                    let address = {
                        assert!(index < 100);
                        self.base_address + 4 + index as u32 * 1000
                    };
                

            
                    ::device_driver::RegisterOperation::<
                        '_,
                        I,
                        u32,
                        field_sets::Foo4,
                        ::device_driver::RW,
                    >::new(self.interface(), address as u32, field_sets::Foo4::new)
                
        }
    
        
        
            ///
            /// Valid index range: 0..100
            
        
        pub fn foo_5(
            &mut self,
             index: usize
            
        ) -> 
         ::device_driver::RegisterOperation<'_, I, u32, field_sets::Foo5, ::device_driver::RW>
            
        {
            
                    let address = {
                        assert!(index < 100);
                        self.base_address + 5 + index as u32 * 1000
                    };
                

            
                    ::device_driver::RegisterOperation::<
                        '_,
                        I,
                        u32,
                        field_sets::Foo5,
                        ::device_driver::RW,
                    >::new(self.interface(), address as u32, field_sets::Foo5::new)
                
        }
    
        
        
            ///
            /// Valid index range: 0..100
            
        
        pub fn foo_6(
            &mut self,
             index: usize
            
        ) -> 
         ::device_driver::RegisterOperation<'_, I, u32, field_sets::Foo6, ::device_driver::RW>
            
        {
            
                    let address = {
                        assert!(index < 100);
                        self.base_address + 6 + index as u32 * 1000
                    };
                

            
                    ::device_driver::RegisterOperation::<
                        '_,
                        I,
                        u32,
                        field_sets::Foo6,
                        ::device_driver::RW,
                    >::new(self.interface(), address as u32, field_sets::Foo6::new)
                
        }
    
        
        
            ///
            /// Valid index range: 0..100
            
        
        pub fn foo_7(
            &mut self,
             index: usize
            
        ) -> 
         ::device_driver::RegisterOperation<'_, I, u32, field_sets::Foo7, ::device_driver::RW>
            
        {
            
                    let address = {
                        assert!(index < 100);
                        self.base_address + 7 + index as u32 * 1000
                    };
                

            
                    ::device_driver::RegisterOperation::<
                        '_,
                        I,
                        u32,
                        field_sets::Foo7,
                        ::device_driver::RW,
                    >::new(self.interface(), address as u32, field_sets::Foo7::new)
                
        }
    
        
        
            ///
            /// Valid index range: 0..100
            
        
        pub fn foo_8(
            &mut self,
             index: usize
            
        ) -> 
         ::device_driver::RegisterOperation<'_, I, u32, field_sets::Foo8, ::device_driver::RW>
            
        {
            
                    let address = {
                        assert!(index < 100);
                        self.base_address + 8 + index as u32 * 1000
                    };
                

            
                    ::device_driver::RegisterOperation::<
                        '_,
                        I,
                        u32,
                        field_sets::Foo8,
                        ::device_driver::RW,
                    >::new(self.interface(), address as u32, field_sets::Foo8::new)
                
        }
    
        
        
            ///
            /// Valid index range: 0..100
            
        
        pub fn foo_9(
            &mut self,
             index: usize
            
        ) -> 
         ::device_driver::RegisterOperation<'_, I, u32, field_sets::Foo9, ::device_driver::RW>
            
        {
            
                    let address = {
                        assert!(index < 100);
                        self.base_address + 9 + index as u32 * 1000
                    };
                

            
                    ::device_driver::RegisterOperation::<
                        '_,
                        I,
                        u32,
                        field_sets::Foo9,
                        ::device_driver::RW,
                    >::new(self.interface(), address as u32, field_sets::Foo9::new)
                
        }
    
        
        
            ///
            /// Valid index range: 0..100
            
        
        pub fn foo_10(
            &mut self,
             index: usize
            
        ) -> 
         ::device_driver::RegisterOperation<'_, I, u32, field_sets::Foo10, ::device_driver::RW>
            
        {
            
                    let address = {
                        assert!(index < 100);
                        self.base_address + 10 + index as u32 * 1000
                    };
                

            
                    ::device_driver::RegisterOperation::<
                        '_,
                        I,
                        u32,
                        field_sets::Foo10,
                        ::device_driver::RW,
                    >::new(self.interface(), address as u32, field_sets::Foo10::new)
                
        }
    
        
        
            ///
            /// Valid index range: 0..100
            
        
        pub fn foo_11(
            &mut self,
             index: usize
            
        ) -> 
         ::device_driver::RegisterOperation<'_, I, u32, field_sets::Foo11, ::device_driver::RW>
            
        {
            
                    let address = {
                        assert!(index < 100);
                        self.base_address + 11 + index as u32 * 1000
                    };
                

            
                    ::device_driver::RegisterOperation::<
                        '_,
                        I,
                        u32,
                        field_sets::Foo11,
                        ::device_driver::RW,
                    >::new(self.interface(), address as u32, field_sets::Foo11::new)
                
        }
    
}


/// Module containing the generated fieldsets of the registers and commands
pub mod field_sets {
    #[allow(unused_imports)]
    use super::*;

    
        

#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Foo0 {
    /// The internal bits
    bits: [u8; 0]
}


impl ::device_driver::FieldSet for Foo0 {
    const SIZE_BITS: u32 = 0;
    fn new_with_zero() -> Self {
        Self::new_zero()
    }
    fn get_inner_buffer(&self) -> &[u8] {
        &self.bits
    }
    fn get_inner_buffer_mut(&mut self) -> &mut [u8] {
        &mut self.bits
    }
}


impl Foo0 {
    /// Create a new instance, loaded with the reset value (if any)
    pub const fn new() -> Self {
        Self { bits: [] }
    }
    /// Create a new instance, loaded with all zeroes
    pub const fn new_zero() -> Self {
        Self { bits: [0; 0] }
    }

    

    

    
}


impl From<[u8; 0]> for Foo0 {
    fn from(bits: [u8; 0]) -> Self {
        Self { bits }
    }
}


impl From<Foo0> for [u8; 0] {
    fn from(val: Foo0) -> Self {
        val.bits
    }
}


impl core::fmt::Debug for Foo0 {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error> {
        let mut d = f.debug_struct("Foo0");
        
        d.finish()
    }
}




impl core::ops::BitAnd for Foo0 {
    type Output = Self;
    fn bitand(mut self, rhs: Self) -> Self::Output {
        self &= rhs;
        self
    }
}

impl core::ops::BitAndAssign for Foo0 {
    fn bitand_assign(&mut self, rhs: Self) {
        for (l, r) in self.bits.iter_mut().zip(&rhs.bits) {
            *l &= *r;
        }
    }
}

impl core::ops::BitOr for Foo0 {
    type Output = Self;
    fn bitor(mut self, rhs: Self) -> Self::Output {
        self |= rhs;
        self
    }
}

impl core::ops::BitOrAssign for Foo0 {
    fn bitor_assign(&mut self, rhs: Self) {
        for (l, r) in self.bits.iter_mut().zip(&rhs.bits) {
            *l |= *r;
        }
    }
}

impl core::ops::BitXor for Foo0 {
    type Output = Self;
    fn bitxor(mut self, rhs: Self) -> Self::Output {
        self ^= rhs;
        self
    }
}

impl core::ops::BitXorAssign for Foo0 {
    fn bitxor_assign(&mut self, rhs: Self) {
        for (l, r) in self.bits.iter_mut().zip(&rhs.bits) {
            *l ^= *r;
        }
    }
}

impl core::ops::Not for Foo0 {
    type Output = Self;
    fn not(mut self) -> Self::Output {
        for val in self.bits.iter_mut() {
            *val = !*val;
        }
        self
    }
}

    
        

#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Foo1 {
    /// The internal bits
    bits: [u8; 0]
}


impl ::device_driver::FieldSet for Foo1 {
    const SIZE_BITS: u32 = 0;
    fn new_with_zero() -> Self {
        Self::new_zero()
    }
    fn get_inner_buffer(&self) -> &[u8] {
        &self.bits
    }
    fn get_inner_buffer_mut(&mut self) -> &mut [u8] {
        &mut self.bits
    }
}


impl Foo1 {
    /// Create a new instance, loaded with the reset value (if any)
    pub const fn new() -> Self {
        Self { bits: [] }
    }
    /// Create a new instance, loaded with all zeroes
    pub const fn new_zero() -> Self {
        Self { bits: [0; 0] }
    }

    

    

    
}


impl From<[u8; 0]> for Foo1 {
    fn from(bits: [u8; 0]) -> Self {
        Self { bits }
    }
}


impl From<Foo1> for [u8; 0] {
    fn from(val: Foo1) -> Self {
        val.bits
    }
}


impl core::fmt::Debug for Foo1 {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error> {
        let mut d = f.debug_struct("Foo1");
        
        d.finish()
    }
}




impl core::ops::BitAnd for Foo1 {
    type Output = Self;
    fn bitand(mut self, rhs: Self) -> Self::Output {
        self &= rhs;
        self
    }
}

impl core::ops::BitAndAssign for Foo1 {
    fn bitand_assign(&mut self, rhs: Self) {
        for (l, r) in self.bits.iter_mut().zip(&rhs.bits) {
            *l &= *r;
        }
    }
}

impl core::ops::BitOr for Foo1 {
    type Output = Self;
    fn bitor(mut self, rhs: Self) -> Self::Output {
        self |= rhs;
        self
    }
}

impl core::ops::BitOrAssign for Foo1 {
    fn bitor_assign(&mut self, rhs: Self) {
        for (l, r) in self.bits.iter_mut().zip(&rhs.bits) {
            *l |= *r;
        }
    }
}

impl core::ops::BitXor for Foo1 {
    type Output = Self;
    fn bitxor(mut self, rhs: Self) -> Self::Output {
        self ^= rhs;
        self
    }
}

impl core::ops::BitXorAssign for Foo1 {
    fn bitxor_assign(&mut self, rhs: Self) {
        for (l, r) in self.bits.iter_mut().zip(&rhs.bits) {
            *l ^= *r;
        }
    }
}

impl core::ops::Not for Foo1 {
    type Output = Self;
    fn not(mut self) -> Self::Output {
        for val in self.bits.iter_mut() {
            *val = !*val;
        }
        self
    }
}

    
        

#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Foo2 {
    /// The internal bits
    bits: [u8; 0]
}


impl ::device_driver::FieldSet for Foo2 {
    const SIZE_BITS: u32 = 0;
    fn new_with_zero() -> Self {
        Self::new_zero()
    }
    fn get_inner_buffer(&self) -> &[u8] {
        &self.bits
    }
    fn get_inner_buffer_mut(&mut self) -> &mut [u8] {
        &mut self.bits
    }
}


impl Foo2 {
    /// Create a new instance, loaded with the reset value (if any)
    pub const fn new() -> Self {
        Self { bits: [] }
    }
    /// Create a new instance, loaded with all zeroes
    pub const fn new_zero() -> Self {
        Self { bits: [0; 0] }
    }

    

    

    
}


impl From<[u8; 0]> for Foo2 {
    fn from(bits: [u8; 0]) -> Self {
        Self { bits }
    }
}


impl From<Foo2> for [u8; 0] {
    fn from(val: Foo2) -> Self {
        val.bits
    }
}


impl core::fmt::Debug for Foo2 {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error> {
        let mut d = f.debug_struct("Foo2");
        
        d.finish()
    }
}




impl core::ops::BitAnd for Foo2 {
    type Output = Self;
    fn bitand(mut self, rhs: Self) -> Self::Output {
        self &= rhs;
        self
    }
}

impl core::ops::BitAndAssign for Foo2 {
    fn bitand_assign(&mut self, rhs: Self) {
        for (l, r) in self.bits.iter_mut().zip(&rhs.bits) {
            *l &= *r;
        }
    }
}

impl core::ops::BitOr for Foo2 {
    type Output = Self;
    fn bitor(mut self, rhs: Self) -> Self::Output {
        self |= rhs;
        self
    }
}

impl core::ops::BitOrAssign for Foo2 {
    fn bitor_assign(&mut self, rhs: Self) {
        for (l, r) in self.bits.iter_mut().zip(&rhs.bits) {
            *l |= *r;
        }
    }
}

impl core::ops::BitXor for Foo2 {
    type Output = Self;
    fn bitxor(mut self, rhs: Self) -> Self::Output {
        self ^= rhs;
        self
    }
}

impl core::ops::BitXorAssign for Foo2 {
    fn bitxor_assign(&mut self, rhs: Self) {
        for (l, r) in self.bits.iter_mut().zip(&rhs.bits) {
            *l ^= *r;
        }
    }
}

impl core::ops::Not for Foo2 {
    type Output = Self;
    fn not(mut self) -> Self::Output {
        for val in self.bits.iter_mut() {
            *val = !*val;
        }
        self
    }
}

    
        

#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Foo3 {
    /// The internal bits
    bits: [u8; 0]
}


impl ::device_driver::FieldSet for Foo3 {
    const SIZE_BITS: u32 = 0;
    fn new_with_zero() -> Self {
        Self::new_zero()
    }
    fn get_inner_buffer(&self) -> &[u8] {
        &self.bits
    }
    fn get_inner_buffer_mut(&mut self) -> &mut [u8] {
        &mut self.bits
    }
}


impl Foo3 {
    /// Create a new instance, loaded with the reset value (if any)
    pub const fn new() -> Self {
        Self { bits: [] }
    }
    /// Create a new instance, loaded with all zeroes
    pub const fn new_zero() -> Self {
        Self { bits: [0; 0] }
    }

    

    

    
}


impl From<[u8; 0]> for Foo3 {
    fn from(bits: [u8; 0]) -> Self {
        Self { bits }
    }
}


impl From<Foo3> for [u8; 0] {
    fn from(val: Foo3) -> Self {
        val.bits
    }
}


impl core::fmt::Debug for Foo3 {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error> {
        let mut d = f.debug_struct("Foo3");
        
        d.finish()
    }
}




impl core::ops::BitAnd for Foo3 {
    type Output = Self;
    fn bitand(mut self, rhs: Self) -> Self::Output {
        self &= rhs;
        self
    }
}

impl core::ops::BitAndAssign for Foo3 {
    fn bitand_assign(&mut self, rhs: Self) {
        for (l, r) in self.bits.iter_mut().zip(&rhs.bits) {
            *l &= *r;
        }
    }
}

impl core::ops::BitOr for Foo3 {
    type Output = Self;
    fn bitor(mut self, rhs: Self) -> Self::Output {
        self |= rhs;
        self
    }
}

impl core::ops::BitOrAssign for Foo3 {
    fn bitor_assign(&mut self, rhs: Self) {
        for (l, r) in self.bits.iter_mut().zip(&rhs.bits) {
            *l |= *r;
        }
    }
}

impl core::ops::BitXor for Foo3 {
    type Output = Self;
    fn bitxor(mut self, rhs: Self) -> Self::Output {
        self ^= rhs;
        self
    }
}

impl core::ops::BitXorAssign for Foo3 {
    fn bitxor_assign(&mut self, rhs: Self) {
        for (l, r) in self.bits.iter_mut().zip(&rhs.bits) {
            *l ^= *r;
        }
    }
}

impl core::ops::Not for Foo3 {
    type Output = Self;
    fn not(mut self) -> Self::Output {
        for val in self.bits.iter_mut() {
            *val = !*val;
        }
        self
    }
}

    
        

#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Foo4 {
    /// The internal bits
    bits: [u8; 0]
}


impl ::device_driver::FieldSet for Foo4 {
    const SIZE_BITS: u32 = 0;
    fn new_with_zero() -> Self {
        Self::new_zero()
    }
    fn get_inner_buffer(&self) -> &[u8] {
        &self.bits
    }
    fn get_inner_buffer_mut(&mut self) -> &mut [u8] {
        &mut self.bits
    }
}


impl Foo4 {
    /// Create a new instance, loaded with the reset value (if any)
    pub const fn new() -> Self {
        Self { bits: [] }
    }
    /// Create a new instance, loaded with all zeroes
    pub const fn new_zero() -> Self {
        Self { bits: [0; 0] }
    }

    

    

    
}


impl From<[u8; 0]> for Foo4 {
    fn from(bits: [u8; 0]) -> Self {
        Self { bits }
    }
}


impl From<Foo4> for [u8; 0] {
    fn from(val: Foo4) -> Self {
        val.bits
    }
}


impl core::fmt::Debug for Foo4 {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error> {
        let mut d = f.debug_struct("Foo4");
        
        d.finish()
    }
}




impl core::ops::BitAnd for Foo4 {
    type Output = Self;
    fn bitand(mut self, rhs: Self) -> Self::Output {
        self &= rhs;
        self
    }
}

impl core::ops::BitAndAssign for Foo4 {
    fn bitand_assign(&mut self, rhs: Self) {
        for (l, r) in self.bits.iter_mut().zip(&rhs.bits) {
            *l &= *r;
        }
    }
}

impl core::ops::BitOr for Foo4 {
    type Output = Self;
    fn bitor(mut self, rhs: Self) -> Self::Output {
        self |= rhs;
        self
    }
}

impl core::ops::BitOrAssign for Foo4 {
    fn bitor_assign(&mut self, rhs: Self) {
        for (l, r) in self.bits.iter_mut().zip(&rhs.bits) {
            *l |= *r;
        }
    }
}

impl core::ops::BitXor for Foo4 {
    type Output = Self;
    fn bitxor(mut self, rhs: Self) -> Self::Output {
        self ^= rhs;
        self
    }
}

impl core::ops::BitXorAssign for Foo4 {
    fn bitxor_assign(&mut self, rhs: Self) {
        for (l, r) in self.bits.iter_mut().zip(&rhs.bits) {
            *l ^= *r;
        }
    }
}

impl core::ops::Not for Foo4 {
    type Output = Self;
    fn not(mut self) -> Self::Output {
        for val in self.bits.iter_mut() {
            *val = !*val;
        }
        self
    }
}

    
        

#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Foo5 {
    /// The internal bits
    bits: [u8; 0]
}


impl ::device_driver::FieldSet for Foo5 {
    const SIZE_BITS: u32 = 0;
    fn new_with_zero() -> Self {
        Self::new_zero()
    }
    fn get_inner_buffer(&self) -> &[u8] {
        &self.bits
    }
    fn get_inner_buffer_mut(&mut self) -> &mut [u8] {
        &mut self.bits
    }
}


impl Foo5 {
    /// Create a new instance, loaded with the reset value (if any)
    pub const fn new() -> Self {
        Self { bits: [] }
    }
    /// Create a new instance, loaded with all zeroes
    pub const fn new_zero() -> Self {
        Self { bits: [0; 0] }
    }

    

    

    
}


impl From<[u8; 0]> for Foo5 {
    fn from(bits: [u8; 0]) -> Self {
        Self { bits }
    }
}


impl From<Foo5> for [u8; 0] {
    fn from(val: Foo5) -> Self {
        val.bits
    }
}


impl core::fmt::Debug for Foo5 {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error> {
        let mut d = f.debug_struct("Foo5");
        
        d.finish()
    }
}




impl core::ops::BitAnd for Foo5 {
    type Output = Self;
    fn bitand(mut self, rhs: Self) -> Self::Output {
        self &= rhs;
        self
    }
}

impl core::ops::BitAndAssign for Foo5 {
    fn bitand_assign(&mut self, rhs: Self) {
        for (l, r) in self.bits.iter_mut().zip(&rhs.bits) {
            *l &= *r;
        }
    }
}

impl core::ops::BitOr for Foo5 {
    type Output = Self;
    fn bitor(mut self, rhs: Self) -> Self::Output {
        self |= rhs;
        self
    }
}

impl core::ops::BitOrAssign for Foo5 {
    fn bitor_assign(&mut self, rhs: Self) {
        for (l, r) in self.bits.iter_mut().zip(&rhs.bits) {
            *l |= *r;
        }
    }
}

impl core::ops::BitXor for Foo5 {
    type Output = Self;
    fn bitxor(mut self, rhs: Self) -> Self::Output {
        self ^= rhs;
        self
    }
}

impl core::ops::BitXorAssign for Foo5 {
    fn bitxor_assign(&mut self, rhs: Self) {
        for (l, r) in self.bits.iter_mut().zip(&rhs.bits) {
            *l ^= *r;
        }
    }
}

impl core::ops::Not for Foo5 {
    type Output = Self;
    fn not(mut self) -> Self::Output {
        for val in self.bits.iter_mut() {
            *val = !*val;
        }
        self
    }
}

    
        

#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Foo6 {
    /// The internal bits
    bits: [u8; 0]
}


impl ::device_driver::FieldSet for Foo6 {
    const SIZE_BITS: u32 = 0;
    fn new_with_zero() -> Self {
        Self::new_zero()
    }
    fn get_inner_buffer(&self) -> &[u8] {
        &self.bits
    }
    fn get_inner_buffer_mut(&mut self) -> &mut [u8] {
        &mut self.bits
    }
}


impl Foo6 {
    /// Create a new instance, loaded with the reset value (if any)
    pub const fn new() -> Self {
        Self { bits: [] }
    }
    /// Create a new instance, loaded with all zeroes
    pub const fn new_zero() -> Self {
        Self { bits: [0; 0] }
    }

    

    

    
}


impl From<[u8; 0]> for Foo6 {
    fn from(bits: [u8; 0]) -> Self {
        Self { bits }
    }
}


impl From<Foo6> for [u8; 0] {
    fn from(val: Foo6) -> Self {
        val.bits
    }
}


impl core::fmt::Debug for Foo6 {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error> {
        let mut d = f.debug_struct("Foo6");
        
        d.finish()
    }
}




impl core::ops::BitAnd for Foo6 {
    type Output = Self;
    fn bitand(mut self, rhs: Self) -> Self::Output {
        self &= rhs;
        self
    }
}

impl core::ops::BitAndAssign for Foo6 {
    fn bitand_assign(&mut self, rhs: Self) {
        for (l, r) in self.bits.iter_mut().zip(&rhs.bits) {
            *l &= *r;
        }
    }
}

impl core::ops::BitOr for Foo6 {
    type Output = Self;
    fn bitor(mut self, rhs: Self) -> Self::Output {
        self |= rhs;
        self
    }
}

impl core::ops::BitOrAssign for Foo6 {
    fn bitor_assign(&mut self, rhs: Self) {
        for (l, r) in self.bits.iter_mut().zip(&rhs.bits) {
            *l |= *r;
        }
    }
}

impl core::ops::BitXor for Foo6 {
    type Output = Self;
    fn bitxor(mut self, rhs: Self) -> Self::Output {
        self ^= rhs;
        self
    }
}

impl core::ops::BitXorAssign for Foo6 {
    fn bitxor_assign(&mut self, rhs: Self) {
        for (l, r) in self.bits.iter_mut().zip(&rhs.bits) {
            *l ^= *r;
        }
    }
}

impl core::ops::Not for Foo6 {
    type Output = Self;
    fn not(mut self) -> Self::Output {
        for val in self.bits.iter_mut() {
            *val = !*val;
        }
        self
    }
}

    
        

#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Foo7 {
    /// The internal bits
    bits: [u8; 0]
}


impl ::device_driver::FieldSet for Foo7 {
    const SIZE_BITS: u32 = 0;
    fn new_with_zero() -> Self {
        Self::new_zero()
    }
    fn get_inner_buffer(&self) -> &[u8] {
        &self.bits
    }
    fn get_inner_buffer_mut(&mut self) -> &mut [u8] {
        &mut self.bits
    }
}


impl Foo7 {
    /// Create a new instance, loaded with the reset value (if any)
    pub const fn new() -> Self {
        Self { bits: [] }
    }
    /// Create a new instance, loaded with all zeroes
    pub const fn new_zero() -> Self {
        Self { bits: [0; 0] }
    }

    

    

    
}


impl From<[u8; 0]> for Foo7 {
    fn from(bits: [u8; 0]) -> Self {
        Self { bits }
    }
}


impl From<Foo7> for [u8; 0] {
    fn from(val: Foo7) -> Self {
        val.bits
    }
}


impl core::fmt::Debug for Foo7 {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error> {
        let mut d = f.debug_struct("Foo7");
        
        d.finish()
    }
}




impl core::ops::BitAnd for Foo7 {
    type Output = Self;
    fn bitand(mut self, rhs: Self) -> Self::Output {
        self &= rhs;
        self
    }
}

impl core::ops::BitAndAssign for Foo7 {
    fn bitand_assign(&mut self, rhs: Self) {
        for (l, r) in self.bits.iter_mut().zip(&rhs.bits) {
            *l &= *r;
        }
    }
}

impl core::ops::BitOr for Foo7 {
    type Output = Self;
    fn bitor(mut self, rhs: Self) -> Self::Output {
        self |= rhs;
        self
    }
}

impl core::ops::BitOrAssign for Foo7 {
    fn bitor_assign(&mut self, rhs: Self) {
        for (l, r) in self.bits.iter_mut().zip(&rhs.bits) {
            *l |= *r;
        }
    }
}

impl core::ops::BitXor for Foo7 {
    type Output = Self;
    fn bitxor(mut self, rhs: Self) -> Self::Output {
        self ^= rhs;
        self
    }
}

impl core::ops::BitXorAssign for Foo7 {
    fn bitxor_assign(&mut self, rhs: Self) {
        for (l, r) in self.bits.iter_mut().zip(&rhs.bits) {
            *l ^= *r;
        }
    }
}

impl core::ops::Not for Foo7 {
    type Output = Self;
    fn not(mut self) -> Self::Output {
        for val in self.bits.iter_mut() {
            *val = !*val;
        }
        self
    }
}

    
        

#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Foo8 {
    /// The internal bits
    bits: [u8; 0]
}


impl ::device_driver::FieldSet for Foo8 {
    const SIZE_BITS: u32 = 0;
    fn new_with_zero() -> Self {
        Self::new_zero()
    }
    fn get_inner_buffer(&self) -> &[u8] {
        &self.bits
    }
    fn get_inner_buffer_mut(&mut self) -> &mut [u8] {
        &mut self.bits
    }
}


impl Foo8 {
    /// Create a new instance, loaded with the reset value (if any)
    pub const fn new() -> Self {
        Self { bits: [] }
    }
    /// Create a new instance, loaded with all zeroes
    pub const fn new_zero() -> Self {
        Self { bits: [0; 0] }
    }

    

    

    
}


impl From<[u8; 0]> for Foo8 {
    fn from(bits: [u8; 0]) -> Self {
        Self { bits }
    }
}


impl From<Foo8> for [u8; 0] {
    fn from(val: Foo8) -> Self {
        val.bits
    }
}


impl core::fmt::Debug for Foo8 {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error> {
        let mut d = f.debug_struct("Foo8");
        
        d.finish()
    }
}




impl core::ops::BitAnd for Foo8 {
    type Output = Self;
    fn bitand(mut self, rhs: Self) -> Self::Output {
        self &= rhs;
        self
    }
}

impl core::ops::BitAndAssign for Foo8 {
    fn bitand_assign(&mut self, rhs: Self) {
        for (l, r) in self.bits.iter_mut().zip(&rhs.bits) {
            *l &= *r;
        }
    }
}

impl core::ops::BitOr for Foo8 {
    type Output = Self;
    fn bitor(mut self, rhs: Self) -> Self::Output {
        self |= rhs;
        self
    }
}

impl core::ops::BitOrAssign for Foo8 {
    fn bitor_assign(&mut self, rhs: Self) {
        for (l, r) in self.bits.iter_mut().zip(&rhs.bits) {
            *l |= *r;
        }
    }
}

impl core::ops::BitXor for Foo8 {
    type Output = Self;
    fn bitxor(mut self, rhs: Self) -> Self::Output {
        self ^= rhs;
        self
    }
}

impl core::ops::BitXorAssign for Foo8 {
    fn bitxor_assign(&mut self, rhs: Self) {
        for (l, r) in self.bits.iter_mut().zip(&rhs.bits) {
            *l ^= *r;
        }
    }
}

impl core::ops::Not for Foo8 {
    type Output = Self;
    fn not(mut self) -> Self::Output {
        for val in self.bits.iter_mut() {
            *val = !*val;
        }
        self
    }
}

    
        

#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Foo9 {
    /// The internal bits
    bits: [u8; 0]
}


impl ::device_driver::FieldSet for Foo9 {
    const SIZE_BITS: u32 = 0;
    fn new_with_zero() -> Self {
        Self::new_zero()
    }
    fn get_inner_buffer(&self) -> &[u8] {
        &self.bits
    }
    fn get_inner_buffer_mut(&mut self) -> &mut [u8] {
        &mut self.bits
    }
}


impl Foo9 {
    /// Create a new instance, loaded with the reset value (if any)
    pub const fn new() -> Self {
        Self { bits: [] }
    }
    /// Create a new instance, loaded with all zeroes
    pub const fn new_zero() -> Self {
        Self { bits: [0; 0] }
    }

    

    

    
}


impl From<[u8; 0]> for Foo9 {
    fn from(bits: [u8; 0]) -> Self {
        Self { bits }
    }
}


impl From<Foo9> for [u8; 0] {
    fn from(val: Foo9) -> Self {
        val.bits
    }
}


impl core::fmt::Debug for Foo9 {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error> {
        let mut d = f.debug_struct("Foo9");
        
        d.finish()
    }
}




impl core::ops::BitAnd for Foo9 {
    type Output = Self;
    fn bitand(mut self, rhs: Self) -> Self::Output {
        self &= rhs;
        self
    }
}

impl core::ops::BitAndAssign for Foo9 {
    fn bitand_assign(&mut self, rhs: Self) {
        for (l, r) in self.bits.iter_mut().zip(&rhs.bits) {
            *l &= *r;
        }
    }
}

impl core::ops::BitOr for Foo9 {
    type Output = Self;
    fn bitor(mut self, rhs: Self) -> Self::Output {
        self |= rhs;
        self
    }
}

impl core::ops::BitOrAssign for Foo9 {
    fn bitor_assign(&mut self, rhs: Self) {
        for (l, r) in self.bits.iter_mut().zip(&rhs.bits) {
            *l |= *r;
        }
    }
}

impl core::ops::BitXor for Foo9 {
    type Output = Self;
    fn bitxor(mut self, rhs: Self) -> Self::Output {
        self ^= rhs;
        self
    }
}

impl core::ops::BitXorAssign for Foo9 {
    fn bitxor_assign(&mut self, rhs: Self) {
        for (l, r) in self.bits.iter_mut().zip(&rhs.bits) {
            *l ^= *r;
        }
    }
}

impl core::ops::Not for Foo9 {
    type Output = Self;
    fn not(mut self) -> Self::Output {
        for val in self.bits.iter_mut() {
            *val = !*val;
        }
        self
    }
}

    
        

#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Foo10 {
    /// The internal bits
    bits: [u8; 0]
}


impl ::device_driver::FieldSet for Foo10 {
    const SIZE_BITS: u32 = 0;
    fn new_with_zero() -> Self {
        Self::new_zero()
    }
    fn get_inner_buffer(&self) -> &[u8] {
        &self.bits
    }
    fn get_inner_buffer_mut(&mut self) -> &mut [u8] {
        &mut self.bits
    }
}


impl Foo10 {
    /// Create a new instance, loaded with the reset value (if any)
    pub const fn new() -> Self {
        Self { bits: [] }
    }
    /// Create a new instance, loaded with all zeroes
    pub const fn new_zero() -> Self {
        Self { bits: [0; 0] }
    }

    

    

    
}


impl From<[u8; 0]> for Foo10 {
    fn from(bits: [u8; 0]) -> Self {
        Self { bits }
    }
}


impl From<Foo10> for [u8; 0] {
    fn from(val: Foo10) -> Self {
        val.bits
    }
}


impl core::fmt::Debug for Foo10 {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error> {
        let mut d = f.debug_struct("Foo10");
        
        d.finish()
    }
}




impl core::ops::BitAnd for Foo10 {
    type Output = Self;
    fn bitand(mut self, rhs: Self) -> Self::Output {
        self &= rhs;
        self
    }
}

impl core::ops::BitAndAssign for Foo10 {
    fn bitand_assign(&mut self, rhs: Self) {
        for (l, r) in self.bits.iter_mut().zip(&rhs.bits) {
            *l &= *r;
        }
    }
}

impl core::ops::BitOr for Foo10 {
    type Output = Self;
    fn bitor(mut self, rhs: Self) -> Self::Output {
        self |= rhs;
        self
    }
}

impl core::ops::BitOrAssign for Foo10 {
    fn bitor_assign(&mut self, rhs: Self) {
        for (l, r) in self.bits.iter_mut().zip(&rhs.bits) {
            *l |= *r;
        }
    }
}

impl core::ops::BitXor for Foo10 {
    type Output = Self;
    fn bitxor(mut self, rhs: Self) -> Self::Output {
        self ^= rhs;
        self
    }
}

impl core::ops::BitXorAssign for Foo10 {
    fn bitxor_assign(&mut self, rhs: Self) {
        for (l, r) in self.bits.iter_mut().zip(&rhs.bits) {
            *l ^= *r;
        }
    }
}

impl core::ops::Not for Foo10 {
    type Output = Self;
    fn not(mut self) -> Self::Output {
        for val in self.bits.iter_mut() {
            *val = !*val;
        }
        self
    }
}

    
        

#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Foo11 {
    /// The internal bits
    bits: [u8; 0]
}


impl ::device_driver::FieldSet for Foo11 {
    const SIZE_BITS: u32 = 0;
    fn new_with_zero() -> Self {
        Self::new_zero()
    }
    fn get_inner_buffer(&self) -> &[u8] {
        &self.bits
    }
    fn get_inner_buffer_mut(&mut self) -> &mut [u8] {
        &mut self.bits
    }
}


impl Foo11 {
    /// Create a new instance, loaded with the reset value (if any)
    pub const fn new() -> Self {
        Self { bits: [] }
    }
    /// Create a new instance, loaded with all zeroes
    pub const fn new_zero() -> Self {
        Self { bits: [0; 0] }
    }

    

    

    
}


impl From<[u8; 0]> for Foo11 {
    fn from(bits: [u8; 0]) -> Self {
        Self { bits }
    }
}


impl From<Foo11> for [u8; 0] {
    fn from(val: Foo11) -> Self {
        val.bits
    }
}


impl core::fmt::Debug for Foo11 {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error> {
        let mut d = f.debug_struct("Foo11");
        
        d.finish()
    }
}




impl core::ops::BitAnd for Foo11 {
    type Output = Self;
    fn bitand(mut self, rhs: Self) -> Self::Output {
        self &= rhs;
        self
    }
}

impl core::ops::BitAndAssign for Foo11 {
    fn bitand_assign(&mut self, rhs: Self) {
        for (l, r) in self.bits.iter_mut().zip(&rhs.bits) {
            *l &= *r;
        }
    }
}

impl core::ops::BitOr for Foo11 {
    type Output = Self;
    fn bitor(mut self, rhs: Self) -> Self::Output {
        self |= rhs;
        self
    }
}

impl core::ops::BitOrAssign for Foo11 {
    fn bitor_assign(&mut self, rhs: Self) {
        for (l, r) in self.bits.iter_mut().zip(&rhs.bits) {
            *l |= *r;
        }
    }
}

impl core::ops::BitXor for Foo11 {
    type Output = Self;
    fn bitxor(mut self, rhs: Self) -> Self::Output {
        self ^= rhs;
        self
    }
}

impl core::ops::BitXorAssign for Foo11 {
    fn bitxor_assign(&mut self, rhs: Self) {
        for (l, r) in self.bits.iter_mut().zip(&rhs.bits) {
            *l ^= *r;
        }
    }
}

impl core::ops::Not for Foo11 {
    type Output = Self;
    fn not(mut self) -> Self::Output {
        for val in self.bits.iter_mut() {
            *val = !*val;
        }
        self
    }
}

    

    /// Enum containing all possible field set types
pub enum FieldSetValue {
    
        
        
        Foo0(Foo0),
    
        
        
        Foo1(Foo1),
    
        
        
        Foo2(Foo2),
    
        
        
        Foo3(Foo3),
    
        
        
        Foo4(Foo4),
    
        
        
        Foo5(Foo5),
    
        
        
        Foo6(Foo6),
    
        
        
        Foo7(Foo7),
    
        
        
        Foo8(Foo8),
    
        
        
        Foo9(Foo9),
    
        
        
        Foo10(Foo10),
    
        
        
        Foo11(Foo11),
    
}
impl core::fmt::Debug for FieldSetValue {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        match self {
            
                
                Self::Foo0(val) => core::fmt::Debug::fmt(val, f),
            
                
                Self::Foo1(val) => core::fmt::Debug::fmt(val, f),
            
                
                Self::Foo2(val) => core::fmt::Debug::fmt(val, f),
            
                
                Self::Foo3(val) => core::fmt::Debug::fmt(val, f),
            
                
                Self::Foo4(val) => core::fmt::Debug::fmt(val, f),
            
                
                Self::Foo5(val) => core::fmt::Debug::fmt(val, f),
            
                
                Self::Foo6(val) => core::fmt::Debug::fmt(val, f),
            
                
                Self::Foo7(val) => core::fmt::Debug::fmt(val, f),
            
                
                Self::Foo8(val) => core::fmt::Debug::fmt(val, f),
            
                
                Self::Foo9(val) => core::fmt::Debug::fmt(val, f),
            
                
                Self::Foo10(val) => core::fmt::Debug::fmt(val, f),
            
                
                Self::Foo11(val) => core::fmt::Debug::fmt(val, f),
            
            #[allow(unreachable_patterns)]
            _ => unreachable!(),
        } 
    }
}




impl From<Foo0> for FieldSetValue {
    fn from(val: Foo0) -> Self {
        Self::Foo0(val)
    }
}


impl From<Foo1> for FieldSetValue {
    fn from(val: Foo1) -> Self {
        Self::Foo1(val)
    }
}


impl From<Foo2> for FieldSetValue {
    fn from(val: Foo2) -> Self {
        Self::Foo2(val)
    }
}


impl From<Foo3> for FieldSetValue {
    fn from(val: Foo3) -> Self {
        Self::Foo3(val)
    }
}


impl From<Foo4> for FieldSetValue {
    fn from(val: Foo4) -> Self {
        Self::Foo4(val)
    }
}


impl From<Foo5> for FieldSetValue {
    fn from(val: Foo5) -> Self {
        Self::Foo5(val)
    }
}


impl From<Foo6> for FieldSetValue {
    fn from(val: Foo6) -> Self {
        Self::Foo6(val)
    }
}


impl From<Foo7> for FieldSetValue {
    fn from(val: Foo7) -> Self {
        Self::Foo7(val)
    }
}


impl From<Foo8> for FieldSetValue {
    fn from(val: Foo8) -> Self {
        Self::Foo8(val)
    }
}


impl From<Foo9> for FieldSetValue {
    fn from(val: Foo9) -> Self {
        Self::Foo9(val)
    }
}


impl From<Foo10> for FieldSetValue {
    fn from(val: Foo10) -> Self {
        Self::Foo10(val)
    }
}


impl From<Foo11> for FieldSetValue {
    fn from(val: Foo11) -> Self {
        Self::Foo11(val)
    }
}

}

input.yaml

config:
  register_address_type: u32
  default_byte_order: LE

Foo0:
  type: register
  address: 0
  size_bits: 0
  repeat:
    count: 100
    stride: 1000
Foo1:
  type: register
  address: 1
  size_bits: 0
  repeat:
    count: 100
    stride: 1000
Foo2:
  type: register
  address: 2
  size_bits: 0
  repeat:
    count: 100
    stride: 1000
Foo3:
  type: register
  address: 3
  size_bits: 0
  repeat:
    count: 100
    stride: 1000
Foo4:
  type: register
  address: 4
  size_bits: 0
  repeat:
    count: 100
    stride: 1000
Foo5:
  type: register
  address: 5
  size_bits: 0
  repeat:
    count: 100
    stride: 1000
Foo6:
  type: register
  address: 6
  size_bits: 0
  repeat:
    count: 100
    stride: 1000
Foo7:
  type: register
  address: 7
  size_bits: 0
  repeat:
    count: 100
    stride: 1000
Foo8:
  type: register
  address: 8
  size_bits: 0
  repeat:
    count: 100
    stride: 1000
Foo9:
  type: register
  address: 9
  size_bits: 0
  repeat:
    count: 100
    stride: 1000
Foo10:
  type: register
  address: 10
  size_bits: 0
  repeat:
    count: 100
    stride: 1000
Foo11:
  type: register
  address: 11
  size_bits: 0
  repeat:
    count: 100
    stride: 1000

repro.rs

pub fn main() {
    
}

pub async fn foo() {
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
    bar().await;
}

pub async fn bar() {

}