rustfmt hangs (forever?) when formatting bindgen-generated code

input.rs:

/* automatically generated by rust-bindgen */

#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)]

#[repr(C)]
#[derive(Debug, Default, Copy)]
pub struct MuchBitfield {
    pub _bitfield_1: [u8; 5usize],
    pub __bindgen_align: [u8; 0usize],
}
#[test]
fn bindgen_test_layout_MuchBitfield() {
    assert_eq!(::std::mem::size_of::<MuchBitfield>() , 5usize , concat ! (
               "Size of: " , stringify ! ( MuchBitfield ) ));
    assert_eq! (::std::mem::align_of::<MuchBitfield>() , 1usize , concat ! (
                "Alignment of " , stringify ! ( MuchBitfield ) ));
}
impl Clone for MuchBitfield {
    fn clone(&self) -> Self { *self }
}
impl MuchBitfield {
    #[inline]
    pub fn m0(&self) -> ::std::os::raw::c_char {
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        let mask = 1u64 as u64;
        let val = (unit_field_val & mask) >> 0usize;
        unsafe { ::std::mem::transmute(val as u8) }
    }
    #[inline]
    pub fn set_m0(&mut self, val: ::std::os::raw::c_char) {
        let mask = 1u64 as u64;
        let val = val as u8 as u64;
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 0usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                *const u8,
                                            &mut self._bitfield_1 as *mut _ as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>());
        }
    }
    #[inline]
    pub fn m1(&self) -> ::std::os::raw::c_char {
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        let mask = 2u64 as u64;
        let val = (unit_field_val & mask) >> 1usize;
        unsafe { ::std::mem::transmute(val as u8) }
    }
    #[inline]
    pub fn set_m1(&mut self, val: ::std::os::raw::c_char) {
        let mask = 2u64 as u64;
        let val = val as u8 as u64;
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 1usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                *const u8,
                                            &mut self._bitfield_1 as *mut _ as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>());
        }
    }
    #[inline]
    pub fn m2(&self) -> ::std::os::raw::c_char {
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        let mask = 4u64 as u64;
        let val = (unit_field_val & mask) >> 2usize;
        unsafe { ::std::mem::transmute(val as u8) }
    }
    #[inline]
    pub fn set_m2(&mut self, val: ::std::os::raw::c_char) {
        let mask = 4u64 as u64;
        let val = val as u8 as u64;
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 2usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                *const u8,
                                            &mut self._bitfield_1 as *mut _ as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>());
        }
    }
    #[inline]
    pub fn m3(&self) -> ::std::os::raw::c_char {
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        let mask = 8u64 as u64;
        let val = (unit_field_val & mask) >> 3usize;
        unsafe { ::std::mem::transmute(val as u8) }
    }
    #[inline]
    pub fn set_m3(&mut self, val: ::std::os::raw::c_char) {
        let mask = 8u64 as u64;
        let val = val as u8 as u64;
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 3usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                *const u8,
                                            &mut self._bitfield_1 as *mut _ as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>());
        }
    }
    #[inline]
    pub fn m4(&self) -> ::std::os::raw::c_char {
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        let mask = 16u64 as u64;
        let val = (unit_field_val & mask) >> 4usize;
        unsafe { ::std::mem::transmute(val as u8) }
    }
    #[inline]
    pub fn set_m4(&mut self, val: ::std::os::raw::c_char) {
        let mask = 16u64 as u64;
        let val = val as u8 as u64;
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 4usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                *const u8,
                                            &mut self._bitfield_1 as *mut _ as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>());
        }
    }
    #[inline]
    pub fn m5(&self) -> ::std::os::raw::c_char {
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        let mask = 32u64 as u64;
        let val = (unit_field_val & mask) >> 5usize;
        unsafe { ::std::mem::transmute(val as u8) }
    }
    #[inline]
    pub fn set_m5(&mut self, val: ::std::os::raw::c_char) {
        let mask = 32u64 as u64;
        let val = val as u8 as u64;
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 5usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                *const u8,
                                            &mut self._bitfield_1 as *mut _ as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>());
        }
    }
    #[inline]
    pub fn m6(&self) -> ::std::os::raw::c_char {
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        let mask = 64u64 as u64;
        let val = (unit_field_val & mask) >> 6usize;
        unsafe { ::std::mem::transmute(val as u8) }
    }
    #[inline]
    pub fn set_m6(&mut self, val: ::std::os::raw::c_char) {
        let mask = 64u64 as u64;
        let val = val as u8 as u64;
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 6usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                *const u8,
                                            &mut self._bitfield_1 as *mut _ as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>());
        }
    }
    #[inline]
    pub fn m7(&self) -> ::std::os::raw::c_char {
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        let mask = 128u64 as u64;
        let val = (unit_field_val & mask) >> 7usize;
        unsafe { ::std::mem::transmute(val as u8) }
    }
    #[inline]
    pub fn set_m7(&mut self, val: ::std::os::raw::c_char) {
        let mask = 128u64 as u64;
        let val = val as u8 as u64;
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 7usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                *const u8,
                                            &mut self._bitfield_1 as *mut _ as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>());
        }
    }
    #[inline]
    pub fn m8(&self) -> ::std::os::raw::c_char {
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        let mask = 256u64 as u64;
        let val = (unit_field_val & mask) >> 8usize;
        unsafe { ::std::mem::transmute(val as u8) }
    }
    #[inline]
    pub fn set_m8(&mut self, val: ::std::os::raw::c_char) {
        let mask = 256u64 as u64;
        let val = val as u8 as u64;
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 8usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                *const u8,
                                            &mut self._bitfield_1 as *mut _ as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>());
        }
    }
    #[inline]
    pub fn m9(&self) -> ::std::os::raw::c_char {
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        let mask = 512u64 as u64;
        let val = (unit_field_val & mask) >> 9usize;
        unsafe { ::std::mem::transmute(val as u8) }
    }
    #[inline]
    pub fn set_m9(&mut self, val: ::std::os::raw::c_char) {
        let mask = 512u64 as u64;
        let val = val as u8 as u64;
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 9usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                *const u8,
                                            &mut self._bitfield_1 as *mut _ as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>());
        }
    }
    #[inline]
    pub fn m10(&self) -> ::std::os::raw::c_char {
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        let mask = 1024u64 as u64;
        let val = (unit_field_val & mask) >> 10usize;
        unsafe { ::std::mem::transmute(val as u8) }
    }
    #[inline]
    pub fn set_m10(&mut self, val: ::std::os::raw::c_char) {
        let mask = 1024u64 as u64;
        let val = val as u8 as u64;
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 10usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                *const u8,
                                            &mut self._bitfield_1 as *mut _ as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>());
        }
    }
    #[inline]
    pub fn m11(&self) -> ::std::os::raw::c_char {
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        let mask = 2048u64 as u64;
        let val = (unit_field_val & mask) >> 11usize;
        unsafe { ::std::mem::transmute(val as u8) }
    }
    #[inline]
    pub fn set_m11(&mut self, val: ::std::os::raw::c_char) {
        let mask = 2048u64 as u64;
        let val = val as u8 as u64;
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 11usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                *const u8,
                                            &mut self._bitfield_1 as *mut _ as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>());
        }
    }
    #[inline]
    pub fn m12(&self) -> ::std::os::raw::c_char {
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        let mask = 4096u64 as u64;
        let val = (unit_field_val & mask) >> 12usize;
        unsafe { ::std::mem::transmute(val as u8) }
    }
    #[inline]
    pub fn set_m12(&mut self, val: ::std::os::raw::c_char) {
        let mask = 4096u64 as u64;
        let val = val as u8 as u64;
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 12usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                *const u8,
                                            &mut self._bitfield_1 as *mut _ as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>());
        }
    }
    #[inline]
    pub fn m13(&self) -> ::std::os::raw::c_char {
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        let mask = 8192u64 as u64;
        let val = (unit_field_val & mask) >> 13usize;
        unsafe { ::std::mem::transmute(val as u8) }
    }
    #[inline]
    pub fn set_m13(&mut self, val: ::std::os::raw::c_char) {
        let mask = 8192u64 as u64;
        let val = val as u8 as u64;
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 13usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                *const u8,
                                            &mut self._bitfield_1 as *mut _ as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>());
        }
    }
    #[inline]
    pub fn m14(&self) -> ::std::os::raw::c_char {
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        let mask = 16384u64 as u64;
        let val = (unit_field_val & mask) >> 14usize;
        unsafe { ::std::mem::transmute(val as u8) }
    }
    #[inline]
    pub fn set_m14(&mut self, val: ::std::os::raw::c_char) {
        let mask = 16384u64 as u64;
        let val = val as u8 as u64;
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 14usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                *const u8,
                                            &mut self._bitfield_1 as *mut _ as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>());
        }
    }
    #[inline]
    pub fn m15(&self) -> ::std::os::raw::c_char {
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        let mask = 32768u64 as u64;
        let val = (unit_field_val & mask) >> 15usize;
        unsafe { ::std::mem::transmute(val as u8) }
    }
    #[inline]
    pub fn set_m15(&mut self, val: ::std::os::raw::c_char) {
        let mask = 32768u64 as u64;
        let val = val as u8 as u64;
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 15usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                *const u8,
                                            &mut self._bitfield_1 as *mut _ as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>());
        }
    }
    #[inline]
    pub fn m16(&self) -> ::std::os::raw::c_char {
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        let mask = 65536u64 as u64;
        let val = (unit_field_val & mask) >> 16usize;
        unsafe { ::std::mem::transmute(val as u8) }
    }
    #[inline]
    pub fn set_m16(&mut self, val: ::std::os::raw::c_char) {
        let mask = 65536u64 as u64;
        let val = val as u8 as u64;
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 16usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                *const u8,
                                            &mut self._bitfield_1 as *mut _ as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>());
        }
    }
    #[inline]
    pub fn m17(&self) -> ::std::os::raw::c_char {
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        let mask = 131072u64 as u64;
        let val = (unit_field_val & mask) >> 17usize;
        unsafe { ::std::mem::transmute(val as u8) }
    }
    #[inline]
    pub fn set_m17(&mut self, val: ::std::os::raw::c_char) {
        let mask = 131072u64 as u64;
        let val = val as u8 as u64;
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 17usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                *const u8,
                                            &mut self._bitfield_1 as *mut _ as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>());
        }
    }
    #[inline]
    pub fn m18(&self) -> ::std::os::raw::c_char {
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        let mask = 262144u64 as u64;
        let val = (unit_field_val & mask) >> 18usize;
        unsafe { ::std::mem::transmute(val as u8) }
    }
    #[inline]
    pub fn set_m18(&mut self, val: ::std::os::raw::c_char) {
        let mask = 262144u64 as u64;
        let val = val as u8 as u64;
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 18usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                *const u8,
                                            &mut self._bitfield_1 as *mut _ as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>());
        }
    }
    #[inline]
    pub fn m19(&self) -> ::std::os::raw::c_char {
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        let mask = 524288u64 as u64;
        let val = (unit_field_val & mask) >> 19usize;
        unsafe { ::std::mem::transmute(val as u8) }
    }
    #[inline]
    pub fn set_m19(&mut self, val: ::std::os::raw::c_char) {
        let mask = 524288u64 as u64;
        let val = val as u8 as u64;
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 19usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                *const u8,
                                            &mut self._bitfield_1 as *mut _ as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>());
        }
    }
    #[inline]
    pub fn m20(&self) -> ::std::os::raw::c_char {
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        let mask = 1048576u64 as u64;
        let val = (unit_field_val & mask) >> 20usize;
        unsafe { ::std::mem::transmute(val as u8) }
    }
    #[inline]
    pub fn set_m20(&mut self, val: ::std::os::raw::c_char) {
        let mask = 1048576u64 as u64;
        let val = val as u8 as u64;
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 20usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                *const u8,
                                            &mut self._bitfield_1 as *mut _ as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>());
        }
    }
    #[inline]
    pub fn m21(&self) -> ::std::os::raw::c_char {
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        let mask = 2097152u64 as u64;
        let val = (unit_field_val & mask) >> 21usize;
        unsafe { ::std::mem::transmute(val as u8) }
    }
    #[inline]
    pub fn set_m21(&mut self, val: ::std::os::raw::c_char) {
        let mask = 2097152u64 as u64;
        let val = val as u8 as u64;
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 21usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                *const u8,
                                            &mut self._bitfield_1 as *mut _ as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>());
        }
    }
    #[inline]
    pub fn m22(&self) -> ::std::os::raw::c_char {
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        let mask = 4194304u64 as u64;
        let val = (unit_field_val & mask) >> 22usize;
        unsafe { ::std::mem::transmute(val as u8) }
    }
    #[inline]
    pub fn set_m22(&mut self, val: ::std::os::raw::c_char) {
        let mask = 4194304u64 as u64;
        let val = val as u8 as u64;
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 22usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                *const u8,
                                            &mut self._bitfield_1 as *mut _ as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>());
        }
    }
    #[inline]
    pub fn m23(&self) -> ::std::os::raw::c_char {
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        let mask = 8388608u64 as u64;
        let val = (unit_field_val & mask) >> 23usize;
        unsafe { ::std::mem::transmute(val as u8) }
    }
    #[inline]
    pub fn set_m23(&mut self, val: ::std::os::raw::c_char) {
        let mask = 8388608u64 as u64;
        let val = val as u8 as u64;
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 23usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                *const u8,
                                            &mut self._bitfield_1 as *mut _ as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>());
        }
    }
    #[inline]
    pub fn m24(&self) -> ::std::os::raw::c_char {
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        let mask = 16777216u64 as u64;
        let val = (unit_field_val & mask) >> 24usize;
        unsafe { ::std::mem::transmute(val as u8) }
    }
    #[inline]
    pub fn set_m24(&mut self, val: ::std::os::raw::c_char) {
        let mask = 16777216u64 as u64;
        let val = val as u8 as u64;
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 24usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                *const u8,
                                            &mut self._bitfield_1 as *mut _ as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>());
        }
    }
    #[inline]
    pub fn m25(&self) -> ::std::os::raw::c_char {
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        let mask = 33554432u64 as u64;
        let val = (unit_field_val & mask) >> 25usize;
        unsafe { ::std::mem::transmute(val as u8) }
    }
    #[inline]
    pub fn set_m25(&mut self, val: ::std::os::raw::c_char) {
        let mask = 33554432u64 as u64;
        let val = val as u8 as u64;
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 25usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                *const u8,
                                            &mut self._bitfield_1 as *mut _ as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>());
        }
    }
    #[inline]
    pub fn m26(&self) -> ::std::os::raw::c_char {
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        let mask = 67108864u64 as u64;
        let val = (unit_field_val & mask) >> 26usize;
        unsafe { ::std::mem::transmute(val as u8) }
    }
    #[inline]
    pub fn set_m26(&mut self, val: ::std::os::raw::c_char) {
        let mask = 67108864u64 as u64;
        let val = val as u8 as u64;
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 26usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                *const u8,
                                            &mut self._bitfield_1 as *mut _ as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>());
        }
    }
    #[inline]
    pub fn m27(&self) -> ::std::os::raw::c_char {
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        let mask = 134217728u64 as u64;
        let val = (unit_field_val & mask) >> 27usize;
        unsafe { ::std::mem::transmute(val as u8) }
    }
    #[inline]
    pub fn set_m27(&mut self, val: ::std::os::raw::c_char) {
        let mask = 134217728u64 as u64;
        let val = val as u8 as u64;
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 27usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                *const u8,
                                            &mut self._bitfield_1 as *mut _ as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>());
        }
    }
    #[inline]
    pub fn m28(&self) -> ::std::os::raw::c_char {
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        let mask = 268435456u64 as u64;
        let val = (unit_field_val & mask) >> 28usize;
        unsafe { ::std::mem::transmute(val as u8) }
    }
    #[inline]
    pub fn set_m28(&mut self, val: ::std::os::raw::c_char) {
        let mask = 268435456u64 as u64;
        let val = val as u8 as u64;
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 28usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                *const u8,
                                            &mut self._bitfield_1 as *mut _ as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>());
        }
    }
    #[inline]
    pub fn m29(&self) -> ::std::os::raw::c_char {
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        let mask = 536870912u64 as u64;
        let val = (unit_field_val & mask) >> 29usize;
        unsafe { ::std::mem::transmute(val as u8) }
    }
    #[inline]
    pub fn set_m29(&mut self, val: ::std::os::raw::c_char) {
        let mask = 536870912u64 as u64;
        let val = val as u8 as u64;
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 29usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                *const u8,
                                            &mut self._bitfield_1 as *mut _ as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>());
        }
    }
    #[inline]
    pub fn m30(&self) -> ::std::os::raw::c_char {
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        let mask =<PHONE_NUMBER>u64 as u64;
        let val = (unit_field_val & mask) >> 30usize;
        unsafe { ::std::mem::transmute(val as u8) }
    }
    #[inline]
    pub fn set_m30(&mut self, val: ::std::os::raw::c_char) {
        let mask =<PHONE_NUMBER>u64 as u64;
        let val = val as u8 as u64;
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 30usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                *const u8,
                                            &mut self._bitfield_1 as *mut _ as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>());
        }
    }
    #[inline]
    pub fn m31(&self) -> ::std::os::raw::c_char {
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        let mask =<PHONE_NUMBER>u64 as u64;
        let val = (unit_field_val & mask) >> 31usize;
        unsafe { ::std::mem::transmute(val as u8) }
    }
    #[inline]
    pub fn set_m31(&mut self, val: ::std::os::raw::c_char) {
        let mask =<PHONE_NUMBER>u64 as u64;
        let val = val as u8 as u64;
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 31usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                *const u8,
                                            &mut self._bitfield_1 as *mut _ as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>());
        }
    }
    #[inline]
    pub fn m32(&self) -> ::std::os::raw::c_char {
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        let mask =<PHONE_NUMBER>u64 as u64;
        let val = (unit_field_val & mask) >> 32usize;
        unsafe { ::std::mem::transmute(val as u8) }
    }
    #[inline]
    pub fn set_m32(&mut self, val: ::std::os::raw::c_char) {
        let mask =<PHONE_NUMBER>u64 as u64;
        let val = val as u8 as u64;
        let mut unit_field_val: u64 = unsafe { ::std::mem::uninitialized() };
        unsafe {
            ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _ as
                                                *const u8,
                                            &mut unit_field_val as *mut u64 as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>())
        };
        unit_field_val &= !mask;
        unit_field_val |= (val << 32usize) & mask;
        unsafe {
            ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                *const u8,
                                            &mut self._bitfield_1 as *mut _ as
                                                *mut u8,
                                            ::std::mem::size_of::<u64>());
        }
    }
    #[inline]
    pub fn new_bitfield_1(m0: ::std::os::raw::c_char,
                          m1: ::std::os::raw::c_char,
                          m2: ::std::os::raw::c_char,
                          m3: ::std::os::raw::c_char,
                          m4: ::std::os::raw::c_char,
                          m5: ::std::os::raw::c_char,
                          m6: ::std::os::raw::c_char,
                          m7: ::std::os::raw::c_char,
                          m8: ::std::os::raw::c_char,
                          m9: ::std::os::raw::c_char,
                          m10: ::std::os::raw::c_char,
                          m11: ::std::os::raw::c_char,
                          m12: ::std::os::raw::c_char,
                          m13: ::std::os::raw::c_char,
                          m14: ::std::os::raw::c_char,
                          m15: ::std::os::raw::c_char,
                          m16: ::std::os::raw::c_char,
                          m17: ::std::os::raw::c_char,
                          m18: ::std::os::raw::c_char,
                          m19: ::std::os::raw::c_char,
                          m20: ::std::os::raw::c_char,
                          m21: ::std::os::raw::c_char,
                          m22: ::std::os::raw::c_char,
                          m23: ::std::os::raw::c_char,
                          m24: ::std::os::raw::c_char,
                          m25: ::std::os::raw::c_char,
                          m26: ::std::os::raw::c_char,
                          m27: ::std::os::raw::c_char,
                          m28: ::std::os::raw::c_char,
                          m29: ::std::os::raw::c_char,
                          m30: ::std::os::raw::c_char,
                          m31: ::std::os::raw::c_char,
                          m32: ::std::os::raw::c_char) -> u64 {
        ({
             ({
                  ({
                       ({
                            ({
                                 ({
                                      ({
                                           ({
                                                ({
                                                     ({
                                                          ({
                                                               ({
                                                                    ({
                                                                         ({
                                                                              ({
                                                                                ({
                                                                                ({
                                                                                ({
                                                                                ({
                                                                                ({
                                                                                ({
                                                                                ({
                                                                                ({
                                                                                ({
                                                                                ({
                                                                                ({
                                                                                ({
                                                                                ({
                                                                                ({
                                                                                ({
                                                                                ({
                                                                                ({
                                                                                ({
                                                                                0
                                                                                }
                                                                                |
                                                                                ((m0
                                                                                as
                                                                                u8
                                                                                as
                                                                                u64)
                                                                                <<
                                                                                0usize)
                                                                                &
                                                                                (1u64
                                                                                as
                                                                                u64))
                                                                                }
                                                                                |
                                                                                ((m1
                                                                                as
                                                                                u8
                                                                                as
                                                                                u64)
                                                                                <<
                                                                                1usize)
                                                                                &
                                                                                (2u64
                                                                                as
                                                                                u64))
                                                                                }
                                                                                |
                                                                                ((m2
                                                                                as
                                                                                u8
                                                                                as
                                                                                u64)
                                                                                <<
                                                                                2usize)
                                                                                &
                                                                                (4u64
                                                                                as
                                                                                u64))
                                                                                }
                                                                                |
                                                                                ((m3
                                                                                as
                                                                                u8
                                                                                as
                                                                                u64)
                                                                                <<
                                                                                3usize)
                                                                                &
                                                                                (8u64
                                                                                as
                                                                                u64))
                                                                                }
                                                                                |
                                                                                ((m4
                                                                                as
                                                                                u8
                                                                                as
                                                                                u64)
                                                                                <<
                                                                                4usize)
                                                                                &
                                                                                (16u64
                                                                                as
                                                                                u64))
                                                                                }
                                                                                |
                                                                                ((m5
                                                                                as
                                                                                u8
                                                                                as
                                                                                u64)
                                                                                <<
                                                                                5usize)
                                                                                &
                                                                                (32u64
                                                                                as
                                                                                u64))
                                                                                }
                                                                                |
                                                                                ((m6
                                                                                as
                                                                                u8
                                                                                as
                                                                                u64)
                                                                                <<
                                                                                6usize)
                                                                                &
                                                                                (64u64
                                                                                as
                                                                                u64))
                                                                                }
                                                                                |
                                                                                ((m7
                                                                                as
                                                                                u8
                                                                                as
                                                                                u64)
                                                                                <<
                                                                                7usize)
                                                                                &
                                                                                (128u64
                                                                                as
                                                                                u64))
                                                                                }
                                                                                |
                                                                                ((m8
                                                                                as
                                                                                u8
                                                                                as
                                                                                u64)
                                                                                <<
                                                                                8usize)
                                                                                &
                                                                                (256u64
                                                                                as
                                                                                u64))
                                                                                }
                                                                                |
                                                                                ((m9
                                                                                as
                                                                                u8
                                                                                as
                                                                                u64)
                                                                                <<
                                                                                9usize)
                                                                                &
                                                                                (512u64
                                                                                as
                                                                                u64))
                                                                                }
                                                                                |
                                                                                ((m10
                                                                                as
                                                                                u8
                                                                                as
                                                                                u64)
                                                                                <<
                                                                                10usize)
                                                                                &
                                                                                (1024u64
                                                                                as
                                                                                u64))
                                                                                }
                                                                                |
                                                                                ((m11
                                                                                as
                                                                                u8
                                                                                as
                                                                                u64)
                                                                                <<
                                                                                11usize)
                                                                                &
                                                                                (2048u64
                                                                                as
                                                                                u64))
                                                                                }
                                                                                |
                                                                                ((m12
                                                                                as
                                                                                u8
                                                                                as
                                                                                u64)
                                                                                <<
                                                                                12usize)
                                                                                &
                                                                                (4096u64
                                                                                as
                                                                                u64))
                                                                                }
                                                                                |
                                                                                ((m13
                                                                                as
                                                                                u8
                                                                                as
                                                                                u64)
                                                                                <<
                                                                                13usize)
                                                                                &
                                                                                (8192u64
                                                                                as
                                                                                u64))
                                                                                }
                                                                                |
                                                                                ((m14
                                                                                as
                                                                                u8
                                                                                as
                                                                                u64)
                                                                                <<
                                                                                14usize)
                                                                                &
                                                                                (16384u64
                                                                                as
                                                                                u64))
                                                                                }
                                                                                |
                                                                                ((m15
                                                                                as
                                                                                u8
                                                                                as
                                                                                u64)
                                                                                <<
                                                                                15usize)
                                                                                &
                                                                                (32768u64
                                                                                as
                                                                                u64))
                                                                                }
                                                                                |
                                                                                ((m16
                                                                                as
                                                                                u8
                                                                                as
                                                                                u64)
                                                                                <<
                                                                                16usize)
                                                                                &
                                                                                (65536u64
                                                                                as
                                                                                u64))
                                                                                }
                                                                                |
                                                                                ((m17
                                                                                as
                                                                                u8
                                                                                as
                                                                                u64)
                                                                                <<
                                                                                17usize)
                                                                                &
                                                                                (131072u64
                                                                                as
                                                                                u64))
                                                                               }
                                                                                |
                                                                                ((m18
                                                                                as
                                                                                u8
                                                                                as
                                                                                u64)
                                                                                <<
                                                                                18usize)
                                                                                &
                                                                                (262144u64
                                                                                as
                                                                                u64))
                                                                          } |
                                                                              ((m19
                                                                                as
                                                                                u8
                                                                                as
                                                                                u64)
                                                                                <<
                                                                                19usize)
                                                                                &
                                                                                (524288u64
                                                                                as
                                                                                u64))
                                                                     } |
                                                                         ((m20
                                                                               as
                                                                               u8
                                                                               as
                                                                               u64)
                                                                              <<
                                                                              20usize)
                                                                             &
                                                                             (1048576u64
                                                                                as
                                                                                u64))
                                                                } |
                                                                    ((m21 as
                                                                          u8
                                                                          as
                                                                          u64)
                                                                         <<
                                                                         21usize)
                                                                        &
                                                                        (2097152u64
                                                                             as
                                                                             u64))
                                                           } |
                                                               ((m22 as u8 as
                                                                     u64) <<
                                                                    22usize) &
                                                                   (4194304u64
                                                                        as
                                                                        u64))
                                                      } |
                                                          ((m23 as u8 as u64)
                                                               << 23usize) &
                                                              (8388608u64 as
                                                                   u64))
                                                 } |
                                                     ((m24 as u8 as u64) <<
                                                          24usize) &
                                                         (16777216u64 as u64))
                                            } |
                                                ((m25 as u8 as u64) <<
                                                     25usize) &
                                                    (33554432u64 as u64))
                                       } |
                                           ((m26 as u8 as u64) << 26usize) &
                                               (67108864u64 as u64))
                                  } |
                                      ((m27 as u8 as u64) << 27usize) &
                                          (134217728u64 as u64))
                             } |
                                 ((m28 as u8 as u64) << 28usize) &
                                     (268435456u64 as u64))
                        } |
                            ((m29 as u8 as u64) << 29usize) &
                                (536870912u64 as u64))
                   } |
                       ((m30 as u8 as u64) << 30usize) &
<PHONE_NUMBER>u64 as u64))
              } | ((m31 as u8 as u64) << 31usize) &<PHONE_NUMBER>u64 as u64))
         } | ((m32 as u8 as u64) << 32usize) &<PHONE_NUMBER>u64 as u64))
    }
}

This command hangs:
$ rustup run nightly rustfmt < input.rs

I'm still on rustfmt 2.2 nightly:
$ rustup run nightly rustfmt --version
0.2.2-nightly ( )

Here is a perf profile:

2.3 nightly is still affected.


fix: medium e2e bug where generate points to repo not model

Checklist:

[x] Commit Message Formatting: Commit titles and messages follow guidelines in the
conventional commits.
[ ] Changelog updated with breaking and/or notable changes for the next minor release.
[ ] Documentation has been updated, if necessary.
[ ] Unit tests have been added, if necessary.
[ ] Functional tests have been added, if necessary.
[ ] E2E Workflow tests have been added, if necessary.

Sorry didn't catch this in the last one

No worries - if the test succeeds on the PR we'll know it's gtg

hmmmmmmm. I think full SDG might not generate MMLU Branch task dir files if its only generating skills. This makes sense, but means we can't test MMLU Branch on the medium job.
@nathan-weinberg I will leave this for you tomorrow to decide if thats ok w/ you. If it is, the solution is to disable MMLU branch on this job

hmmmmmmm. I think full SDG might not generate MMLU Branch task dir files if its only generating skills. This makes sense, but means we can't test MMLU Branch on the medium job.
@nathan-weinberg I will leave this for you tomorrow to decide if thats ok w/ you. If it is, the solution is to disable MMLU branch on this job

Yeah no worries I'll remove the commit tomorrow


Improve SSR integration documentation

SSR integration documentation not match with real example. It's a bit confusing when you trying to do it. This PR makes it more clear

Usually the main bundle and react render code is at the bottom of the file anyway why add an extra layer of indirection?


2021.2 Main Scene Doesnt Load

First, thank you and great job on the loader.
Im using 2021.2. The loading screen appears, but just hangs there forever. Is there a method that needs to bee called in order to get the main scene to load after the WebGL loader has completed d/loading?
After further looking into it, when im using a new template... the build doesn't generate the folder "TemplateData".

My mistake. I was using 2019 package rather than 2020.

HI!
I am using 2021.2 as well and I keep getting the same error:
C:\Program Files\Unity\Hub\Editor\2021.2.0f1\Editor\Data\PlaybackEngines\WebGLSupport\BuildTools\Preprocess.js:67
throw "Preprocessor error "" + e + "" occured in file "" + locals.inputPath + "" when evaluating expression "" + expression + """;
^
Preprocessor error "ReferenceError: HIDE_FULL_SCREEN_BUTTON is not defined" occured in file "C:/Users/Fox/Unity/Expo_Enap_R6/Assets/WebGLTemplates/Better2020/index.html" when evaluating expression " HIDE_FULL_SCREEN_BUTTON "
(Use node --trace-uncaught ... to show where the exception was thrown)
UnityEngine.GUIUtility:ProcessEvent (int,intptr,bool&)
Is it fixable? I am totally noob in html :(

At the moment I'm unable to reproduce the issue.
Using with 2021.2.7f1
https://www.youtube.com/watch?v=-Fkw9HEAer8
Using with 2021.3.6f1
https://www.youtube.com/watch?v=bK6tQtIhDcg
Maybe try starting with a blank project like in the video and see if you still run into the issue? If not then maybe try adding in whatever other plugins/etc your using and maybe you can find the issue?


click != drag

The click event should not trigger the drag event. I should be able to have a div which is clickable but also draggable. See Trello as a good example of this.
The only option I've been able to find is adding a nested, clickable element within a draggable div. This is a much less than desirable UX and rather unintuitive.

There is a bug by calling a callback on release:
this -> doesnt call the callback
$rootScope.$broadcast('draggable:end', {x:_mx, y:_my, tx:_tx, ty:_ty, event:evt, element:element, data:_data, callback:onDragComplete, uid: _myid});
And this --> does
$rootScope.$broadcast('draggable:end', {x:_mx, y:_my, tx:_tx, ty:_ty, event:evt, element:element, data:_data, callback:onDragComplete});
additional parameter uid: _myid is the problem

I don't believe this should be closed. I believe the original issue is that an element should be draggable and clickable. (Not nested elements).
I am facing the same issue now. I have elements that can be dragged to a location. These very same elements has a click action associated to them. (Click to display additional behavior).

Like @rancoisgrogor already said, this ticket should not be closed because the original issue is not solved.
I have found a lot of solutions with nested elements but I need the same element to be clickable and draggable.
Is there any way or could it be fixed?

Upon clicking my draggables, only the drop event fires, no drag event.
Using drop event I was able to check whether the object being "dropped" was previously dragged, or if it should be treated as clicked instead.


webapp updates to support v2.0 fastspecfit catalogs

The web-app is not yet public and will likely require some additional updates but I'd like to get these changes in now.
Unit tests are failing for known reasons but will be fixed in a separate PR.

Pull Request Test Coverage Report for Build<PHONE_NUMBER>

0 of 9 (0.0%)  changed or added relevant lines in 2 files are covered.
No unchanged relevant lines lost coverage.
Overall coverage remained the same at 57.898%

Changes Missing Coverage
Covered Lines
Changed/Added Lines
%

py/fastspecfit/continuum.py
0
4
0.0%

py/fastspecfit/emlines.py
0
5
0.0%

Totals

Change from base Build<PHONE_NUMBER>:
0.0%

Covered Lines:
2049

Relevant Lines:
3539

💛  - Coveralls

Pull Request Test Coverage Report for Build<PHONE_NUMBER>
Warning: This coverage report may be inaccurate.
This pull request's base commit is no longer the HEAD commit of its target branch. This means it includes changes from outside the original pull request, including, potentially, unrelated coverage changes.

For more information on this, see Tracking coverage changes with pull request builds.
To avoid this issue with future PRs, see these Recommended CI Configurations.
For a quick fix, rebase this PR at GitHub. Your next report should be accurate.

Details

0 of 9 (0.0%)  changed or added relevant lines in 2 files are covered.
No unchanged relevant lines lost coverage.
Overall coverage remained the same at 57.898%

Changes Missing Coverage
Covered Lines
Changed/Added Lines
%

py/fastspecfit/continuum.py
0
4
0.0%

py/fastspecfit/emlines.py
0
5
0.0%

Totals

Change from base Build<PHONE_NUMBER>:
0.0%

Covered Lines:
2049

Relevant Lines:
3539

💛  - Coveralls


UF-5358: Created Camunda service-template

Some thougts:

In my research I've come to understand that we need to define our own tenant specific auto depoyer, maybe its a good idea to implement/use those classes in the template (to minimize the boiler plate code needed to get started with tenant specific deployments)? I have some classes to sell that does just that 😄.
Isn't it a good idea to also have an embryo of an API for starting and updating processes in the template? If yes, then I've got classes for that too.


Player dont stop buffering ui state (statusbar)

Issue overview

[X] Incorrect behavior
[ ] Feature request
[ ] Crash
[ ] Help / documentation
[ ] Other: classification

Description of the problem
The Player don't stop the buffering (maybe only ui state) anymore again.
You could see this in the statusbar.
Environment information

Library version: newest
iOS version: 9.3.5
Device: All

Reproducibility

Check the correct option below

[X] Always reproducible
[ ] Difficult to reproduce

Code sample
I allocate the players like that:
//----------------------------------------------------------------------------------------------
-(RTSMediaPlayerController*)mediaplayerWithUrl:(NSURL*)url
//----------------------------------------------------------------------------------------------
{
if (!url) { return nil; }
[self.mediaplayer pause];
self.mediaplayer = nil;
return [[RTSMediaPlayerController alloc] initWithContentURL:url];
}
i stop like that :
[self.mediaplayer pause];
Steps to reproduce

Play a realtime audio (for example radio stream: https://www.crowdradio.de/kunden/puls_br/puls_hifi.m3u )

stop it

the statusbar spinning wheel never stop again (but on cpu load i cant see something interesting, its around 0-2% load)

The Problem is only with Livestreams, the solution is to force a hard source reset over the reset functions.
[mediaplayer reset];
Could be closed?

Hi,
Your issue is strange. Our implementation does not alter the status bar activity indicator visibility in any way. Do your code update it somehow?
Thanks.

Hey, sorry for the late response @defagos.
After your hint i checked the code and it seems its AFNetwork Network Indicator Scanner. But maybe thats really a hint for a problem. Because, if the source is not a livestream all works fine and only with livestreams the scanner has its problems. If i dealloc the player via your reset func all works, if i only set the player to nil it doesnt.
For me its fixed, but maybe you could find something with the hint?
Thx and keep going on ;)

Thanks for your answer. It is still odd since what the player basically requires is a URL. Issues with how AFNetworking deals with the status indicator should therefore not arise anymore once the player plays its content, as AFNetworking involvement should be limited to retrieving the URL.
The only issue I could think of is if you implemented a data source (RTSMediaPlayerControllerDataSource) to retrieve the URL using AFNetworking. We had issues in the past (especially with canceling connections) and, depending on how the data source itself is implemented, I could imagine some subtle bugs could arise. If you are playing the URL directly, then those problems are not relevant to you.
We greatly simplified the URL retrieval process in our next 2.0 release of the library, though, by removing the data source concept altogether. The work on it is nearly done on develop, but we will only deliver an official tag when this version is in production within our applications (probably in the next couple of months).
Thanks again for your feedback. I will close this ticket for now, do not hesitate to reopen it if you encounter similar issues in the future.
Best regards.


auto macro overwrites.

The macro  cs_o365_success_login_outside_country_filter is set at search * (the default)
However there does not seem to be a logical way to change this.
The macro cs_o365_failed_login_outside_country_filter is edited by updating the "macro settings | o365 | cs_0365 failed login..." detail and then updating.
There does not seem to be a reciprocating option for cs_o365_success_login detail field.
Updating the macro directly simply sees it over written with the default "search *" some 5-mins later.
How do you update this macro?

@dabunn - You can just go to
From Cyences App > Splunk Settings > Saved Searches, Reports and Alerts page > Select "O365 - Successful Login Outside Country" alert > Go to the end of the page and select Cyences Notable Event Action > Expand it and there you will be able to update it.
Not everyone understands macro, but everyone knows about alerts so you can update right where the alert is. That's the new feature we have implemented.

So - Let me get this right
You update the failed login filter macro through the app interface as I describe above.
But; whilst the successful login macro exists, you can't update that, you edit the actual alert directly.
The problem with that is - the next release of the app will over write all the alerts setting them to default, that was the whole point about using macros.

@dabunn - No I meant in the alert action not directly under the alert query. That will not override on upgrade.

@dabunn - Have you tried this way to update the filter?

Closing the issue. Feel free to reopen if needed