Miscellaneous clippy fixes. (#1128)

sunfishcode · web-flow · commit 25c54dc766b5 · 2024-08-26T06:21:57.000-07:00
diff --git a/src/backend/libc/event/epoll.rs b/src/backend/libc/event/epoll.rs
@@ -294,6 +294,11 @@ impl<'a> Iterator for Iter<'a> {
     fn next(&mut self) -> Option<Self::Item> {
         self.iter.next()
     }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.iter.size_hint()
+    }
 }
 
 /// A record of an event that occurred.
diff --git a/src/backend/libc/event/poll_fd.rs b/src/backend/libc/event/poll_fd.rs
@@ -63,8 +63,8 @@ pub struct PollFd<'fd> {
 }
 
 impl<'fd> fmt::Debug for PollFd<'fd> {
-    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt.debug_struct("PollFd")
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("PollFd")
             .field("fd", &self.pollfd.fd)
             .field("events", &self.pollfd.events)
             .field("revents", &self.pollfd.revents)
diff --git a/src/backend/libc/net/addr.rs b/src/backend/libc/net/addr.rs
@@ -194,16 +194,16 @@ impl Hash for SocketAddrUnix {
 
 #[cfg(unix)]
 impl fmt::Debug for SocketAddrUnix {
-    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         if let Some(path) = self.path() {
-            path.fmt(fmt)
+            path.fmt(f)
         } else {
             #[cfg(linux_kernel)]
             if let Some(name) = self.abstract_name() {
-                return name.fmt(fmt);
+                return name.fmt(f);
             }
 
-            "(unnamed)".fmt(fmt)
+            "(unnamed)".fmt(f)
         }
     }
 }
diff --git a/src/backend/libc/net/sockopt.rs b/src/backend/libc/net/sockopt.rs
@@ -915,9 +915,10 @@ pub(crate) fn set_tcp_congestion(fd: BorrowedFd<'_>, value: &str) -> io::Result<
 ))]
 #[inline]
 pub(crate) fn get_tcp_congestion(fd: BorrowedFd<'_>) -> io::Result<String> {
+    const OPTLEN: c::socklen_t = 16;
+
     let level = c::IPPROTO_TCP;
     let optname = c::TCP_CONGESTION;
-    const OPTLEN: c::socklen_t = 16;
     let mut value = MaybeUninit::<[MaybeUninit<u8>; OPTLEN as usize]>::uninit();
     let mut optlen = OPTLEN;
     getsockopt_raw(fd, level, optname, &mut value, &mut optlen)?;
diff --git a/src/backend/libc/pipe/syscalls.rs b/src/backend/libc/pipe/syscalls.rs
@@ -54,7 +54,7 @@ pub(crate) fn pipe_with(flags: PipeFlags) -> io::Result<(OwnedFd, OwnedFd)> {
 
 #[cfg(linux_kernel)]
 #[inline]
-pub fn splice(
+pub(crate) fn splice(
     fd_in: BorrowedFd<'_>,
     off_in: Option<&mut u64>,
     fd_out: BorrowedFd<'_>,
@@ -79,7 +79,7 @@ pub fn splice(
 
 #[cfg(linux_kernel)]
 #[inline]
-pub unsafe fn vmsplice(
+pub(crate) unsafe fn vmsplice(
     fd: BorrowedFd<'_>,
     bufs: &[IoSliceRaw<'_>],
     flags: SpliceFlags,
@@ -94,7 +94,7 @@ pub unsafe fn vmsplice(
 
 #[cfg(linux_kernel)]
 #[inline]
-pub fn tee(
+pub(crate) fn tee(
     fd_in: BorrowedFd<'_>,
     fd_out: BorrowedFd<'_>,
     len: usize,
diff --git a/src/backend/linux_raw/event/epoll.rs b/src/backend/linux_raw/event/epoll.rs
@@ -304,6 +304,11 @@ impl<'a> Iterator for Iter<'a> {
     fn next(&mut self) -> Option<Self::Item> {
         self.iter.next()
     }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.iter.size_hint()
+    }
 }
 
 /// A record of an event that occurred.
diff --git a/src/backend/linux_raw/io/syscalls.rs b/src/backend/linux_raw/io/syscalls.rs
@@ -277,7 +277,7 @@ pub(crate) fn is_read_write(fd: BorrowedFd<'_>) -> io::Result<(bool, bool)> {
         match unsafe {
             crate::backend::net::syscalls::recv(
                 fd,
-                buf.as_mut_ptr() as *mut u8,
+                buf.as_mut_ptr().cast::<u8>(),
                 1,
                 RecvFlags::PEEK | RecvFlags::DONTWAIT,
             )
diff --git a/src/backend/linux_raw/net/addr.rs b/src/backend/linux_raw/net/addr.rs
@@ -152,13 +152,13 @@ impl Hash for SocketAddrUnix {
 }
 
 impl fmt::Debug for SocketAddrUnix {
-    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         if let Some(path) = self.path() {
-            path.fmt(fmt)
+            path.fmt(f)
         } else if let Some(name) = self.abstract_name() {
-            name.fmt(fmt)
+            name.fmt(f)
         } else {
-            "(unnamed)".fmt(fmt)
+            "(unnamed)".fmt(f)
         }
     }
 }
diff --git a/src/backend/linux_raw/net/netdevice.rs b/src/backend/linux_raw/net/netdevice.rs
@@ -3,6 +3,7 @@
 use crate::backend::io::syscalls::ioctl;
 use crate::fd::AsFd;
 use crate::io;
+use core::ptr::addr_of_mut;
 use core::{slice, str};
 use linux_raw_sys::ctypes::c_char;
 use linux_raw_sys::ioctl::SIOCGIFINDEX;
@@ -32,7 +33,7 @@ pub(crate) fn name_to_index(fd: impl AsFd, if_name: &str) -> io::Result<u32> {
     };
     unsafe { ifreq.ifr_ifrn.ifrn_name[..if_name_bytes.len()].copy_from_slice(if_name_bytes) };
 
-    unsafe { ioctl(fd.as_fd(), SIOCGIFINDEX, &mut ifreq as *mut ifreq as _) }?;
+    unsafe { ioctl(fd.as_fd(), SIOCGIFINDEX, addr_of_mut!(ifreq).cast()) }?;
     let index = unsafe { ifreq.ifr_ifru.ifru_ivalue };
     Ok(index as u32)
 }
@@ -46,7 +47,7 @@ pub(crate) fn index_to_name(fd: impl AsFd, index: u32) -> io::Result<String> {
         },
     };
 
-    unsafe { ioctl(fd.as_fd(), SIOCGIFNAME, &mut ifreq as *mut ifreq as _) }?;
+    unsafe { ioctl(fd.as_fd(), SIOCGIFNAME, addr_of_mut!(ifreq).cast()) }?;
 
     if let Some(nul_byte) = unsafe { ifreq.ifr_ifrn.ifrn_name }
         .iter()
diff --git a/src/backend/linux_raw/net/sockopt.rs b/src/backend/linux_raw/net/sockopt.rs
@@ -709,7 +709,7 @@ pub(crate) fn set_tcp_keepidle(fd: BorrowedFd<'_>, duration: Duration) -> io::Re
 #[inline]
 pub(crate) fn get_tcp_keepidle(fd: BorrowedFd<'_>) -> io::Result<Duration> {
     let secs: c::c_uint = getsockopt(fd, c::IPPROTO_TCP, c::TCP_KEEPIDLE)?;
-    Ok(Duration::from_secs(secs as u64))
+    Ok(Duration::from_secs(secs.into()))
 }
 
 #[inline]
@@ -721,7 +721,7 @@ pub(crate) fn set_tcp_keepintvl(fd: BorrowedFd<'_>, duration: Duration) -> io::R
 #[inline]
 pub(crate) fn get_tcp_keepintvl(fd: BorrowedFd<'_>) -> io::Result<Duration> {
     let secs: c::c_uint = getsockopt(fd, c::IPPROTO_TCP, c::TCP_KEEPINTVL)?;
-    Ok(Duration::from_secs(secs as u64))
+    Ok(Duration::from_secs(secs.into()))
 }
 
 #[inline]
@@ -755,9 +755,10 @@ pub(crate) fn set_tcp_congestion(fd: BorrowedFd<'_>, value: &str) -> io::Result<
 #[cfg(feature = "alloc")]
 #[inline]
 pub(crate) fn get_tcp_congestion(fd: BorrowedFd<'_>) -> io::Result<String> {
+    const OPTLEN: c::socklen_t = 16;
+
     let level = c::IPPROTO_TCP;
     let optname = c::TCP_CONGESTION;
-    const OPTLEN: c::socklen_t = 16;
     let mut value = MaybeUninit::<[MaybeUninit<u8>; OPTLEN as usize]>::uninit();
     let mut optlen = OPTLEN;
     getsockopt_raw(fd, level, optname, &mut value, &mut optlen)?;
diff --git a/src/backend/linux_raw/pipe/syscalls.rs b/src/backend/linux_raw/pipe/syscalls.rs
@@ -57,7 +57,7 @@ pub(crate) fn pipe_with(flags: PipeFlags) -> io::Result<(OwnedFd, OwnedFd)> {
 }
 
 #[inline]
-pub fn splice(
+pub(crate) fn splice(
     fd_in: BorrowedFd<'_>,
     off_in: Option<&mut u64>,
     fd_out: BorrowedFd<'_>,
@@ -79,7 +79,7 @@ pub fn splice(
 }
 
 #[inline]
-pub unsafe fn vmsplice(
+pub(crate) unsafe fn vmsplice(
     fd: BorrowedFd<'_>,
     bufs: &[IoSliceRaw<'_>],
     flags: SpliceFlags,
@@ -89,7 +89,7 @@ pub unsafe fn vmsplice(
 }
 
 #[inline]
-pub fn tee(
+pub(crate) fn tee(
     fd_in: BorrowedFd<'_>,
     fd_out: BorrowedFd<'_>,
     len: usize,
diff --git a/src/backend/linux_raw/vdso_wrappers.rs b/src/backend/linux_raw/vdso_wrappers.rs
@@ -8,6 +8,7 @@
 //! passes them uninitialized memory buffers. This file also calls vDSO
 //! functions.
 #![allow(unsafe_code)]
+#![allow(clippy::missing_transmute_annotations)]
 
 #[cfg(target_arch = "x86")]
 use super::reg::{ArgReg, RetReg, SyscallNumber, A0, A1, A2, A3, A4, A5, R0};
diff --git a/src/bitcast.rs b/src/bitcast.rs
@@ -14,7 +14,12 @@ macro_rules! bitcast {
         } else if false {
             // Ensure that the source and destinations are the same size.
             // SAFETY: This code is under an `if false`.
-            #[allow(unsafe_code, unused_unsafe, clippy::useless_transmute)]
+            #[allow(
+                unsafe_code,
+                unused_unsafe,
+                clippy::useless_transmute,
+                clippy::missing_transmute_annotations
+            )]
             unsafe {
                 ::core::mem::transmute($x)
             }
diff --git a/src/buffer.rs b/src/buffer.rs
@@ -16,6 +16,6 @@ pub(super) unsafe fn split_init(
     init: usize,
 ) -> (&mut [u8], &mut [MaybeUninit<u8>]) {
     let (init, uninit) = buf.split_at_mut(init);
-    let init = slice::from_raw_parts_mut(init.as_mut_ptr() as *mut u8, init.len());
+    let init = slice::from_raw_parts_mut(init.as_mut_ptr().cast::<u8>(), init.len());
     (init, uninit)
 }
diff --git a/src/fs/fd.rs b/src/fs/fd.rs
@@ -59,8 +59,8 @@ pub struct Timestamps {
 }
 
 impl fmt::Debug for Timestamps {
-    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt.debug_struct("Timestamps")
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Timestamps")
             .field("last_access.tv_sec", &self.last_access.tv_sec)
             .field("last_access.tv_nsec", &self.last_access.tv_nsec)
             .field("last_modification.tv_sec", &self.last_modification.tv_sec)
diff --git a/src/io/errno.rs b/src/io/errno.rs
@@ -24,27 +24,27 @@ impl Errno {
 }
 
 impl fmt::Display for Errno {
-    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         #[cfg(feature = "std")]
         {
-            std::io::Error::from(*self).fmt(fmt)
+            std::io::Error::from(*self).fmt(f)
         }
         #[cfg(not(feature = "std"))]
         {
-            write!(fmt, "os error {}", self.raw_os_error())
+            write!(f, "os error {}", self.raw_os_error())
         }
     }
 }
 
 impl fmt::Debug for Errno {
-    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         #[cfg(feature = "std")]
         {
-            std::io::Error::from(*self).fmt(fmt)
+            std::io::Error::from(*self).fmt(f)
         }
         #[cfg(not(feature = "std"))]
         {
-            write!(fmt, "os error {}", self.raw_os_error())
+            write!(f, "os error {}", self.raw_os_error())
         }
     }
 }
diff --git a/src/io/read_write.rs b/src/io/read_write.rs
@@ -55,8 +55,9 @@ pub fn read_uninit<Fd: AsFd>(
     buf: &mut [MaybeUninit<u8>],
 ) -> io::Result<(&mut [u8], &mut [MaybeUninit<u8>])> {
     // Get number of initialized bytes.
-    let length =
-        unsafe { backend::io::syscalls::read(fd.as_fd(), buf.as_mut_ptr() as *mut u8, buf.len()) };
+    let length = unsafe {
+        backend::io::syscalls::read(fd.as_fd(), buf.as_mut_ptr().cast::<u8>(), buf.len())
+    };
 
     // Split into the initialized and uninitialized portions.
     Ok(unsafe { split_init(buf, length?) })
@@ -129,7 +130,7 @@ pub fn pread_uninit<Fd: AsFd>(
     offset: u64,
 ) -> io::Result<(&mut [u8], &mut [MaybeUninit<u8>])> {
     let length = unsafe {
-        backend::io::syscalls::pread(fd.as_fd(), buf.as_mut_ptr() as *mut u8, buf.len(), offset)
+        backend::io::syscalls::pread(fd.as_fd(), buf.as_mut_ptr().cast::<u8>(), buf.len(), offset)
     };
     Ok(unsafe { split_init(buf, length?) })
 }
diff --git a/src/io_uring.rs b/src/io_uring.rs
@@ -1059,10 +1059,10 @@ impl Default for io_uring_user_data {
 }
 
 impl core::fmt::Debug for io_uring_user_data {
-    fn fmt(&self, fmt: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         // SAFETY: Just format as a `u64`, since formatting doesn't preserve
         // provenance, and we don't have a discriminant.
-        unsafe { self.u64_.fmt(fmt) }
+        unsafe { self.u64_.fmt(f) }
     }
 }
 
diff --git a/src/ioctl/mod.rs b/src/ioctl/mod.rs
@@ -217,9 +217,10 @@ impl Opcode {
         number: u8,
         data_size: usize,
     ) -> Self {
-        if data_size > RawOpcode::MAX as usize {
-            panic!("data size is too large");
-        }
+        assert!(
+            data_size <= RawOpcode::MAX as usize,
+            "data size is too large"
+        );
 
         Self::old(platform::compose_opcode(
             direction,
diff --git a/src/net/send_recv/mod.rs b/src/net/send_recv/mod.rs
@@ -78,7 +78,7 @@ pub fn recv_uninit<Fd: AsFd>(
     flags: RecvFlags,
 ) -> io::Result<(&mut [u8], &mut [MaybeUninit<u8>])> {
     let length = unsafe {
-        backend::net::syscalls::recv(fd.as_fd(), buf.as_mut_ptr() as *mut u8, buf.len(), flags)
+        backend::net::syscalls::recv(fd.as_fd(), buf.as_mut_ptr().cast::<u8>(), buf.len(), flags)
     };
 
     Ok(unsafe { split_init(buf, length?) })
@@ -168,7 +168,12 @@ pub fn recvfrom_uninit<Fd: AsFd>(
     flags: RecvFlags,
 ) -> io::Result<(&mut [u8], &mut [MaybeUninit<u8>], Option<SocketAddrAny>)> {
     let (length, addr) = unsafe {
-        backend::net::syscalls::recvfrom(fd.as_fd(), buf.as_mut_ptr() as *mut u8, buf.len(), flags)?
+        backend::net::syscalls::recvfrom(
+            fd.as_fd(),
+            buf.as_mut_ptr().cast::<u8>(),
+            buf.len(),
+            flags,
+        )?
     };
     let (init, uninit) = unsafe { split_init(buf, length) };
     Ok((init, uninit, addr))
diff --git a/src/net/socket_addr_any.rs b/src/net/socket_addr_any.rs
@@ -109,14 +109,14 @@ impl SocketAddrAny {
 
 #[cfg(feature = "std")]
 impl fmt::Debug for SocketAddrAny {
-    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Self::V4(v4) => v4.fmt(fmt),
-            Self::V6(v6) => v6.fmt(fmt),
+            Self::V4(v4) => v4.fmt(f),
+            Self::V6(v6) => v6.fmt(f),
             #[cfg(unix)]
-            Self::Unix(unix) => unix.fmt(fmt),
+            Self::Unix(unix) => unix.fmt(f),
             #[cfg(target_os = "linux")]
-            Self::Xdp(xdp) => xdp.fmt(fmt),
+            Self::Xdp(xdp) => xdp.fmt(f),
         }
     }
 }
diff --git a/src/path/arg.rs b/src/path/arg.rs
@@ -90,9 +90,9 @@ pub trait Arg {
 }
 
 /// Runs a closure on `arg` where `A` is mapped to a `&CStr`
-pub fn option_into_with_c_str<T, F, A: Arg>(arg: Option<A>, f: F) -> io::Result<T>
+pub fn option_into_with_c_str<T, F, A>(arg: Option<A>, f: F) -> io::Result<T>
 where
-    A: Sized,
+    A: Arg + Sized,
     F: FnOnce(Option<&CStr>) -> io::Result<T>,
 {
     if let Some(arg) = arg {
diff --git a/src/path/dec_int.rs b/src/path/dec_int.rs
@@ -114,7 +114,7 @@ impl AsRef<Path> for DecInt {
 
 #[cfg(feature = "std")]
 impl fmt::Debug for DecInt {
-    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.as_str().fmt(fmt)
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.as_str().fmt(f)
     }
 }
diff --git a/src/process/ioctl.rs b/src/process/ioctl.rs
diff --git a/src/process/sched.rs b/src/process/sched.rs
diff --git a/src/rand/getrandom.rs b/src/rand/getrandom.rs
diff --git a/src/system.rs b/src/system.rs
diff --git a/src/thread/clock.rs b/src/thread/clock.rs
diff --git a/src/thread/prctl.rs b/src/thread/prctl.rs
diff --git a/tests/backends.rs b/tests/backends.rs
diff --git a/tests/fs/readdir.rs b/tests/fs/readdir.rs
diff --git a/tests/fs/readlinkat.rs b/tests/fs/readlinkat.rs
diff --git a/tests/io_uring/register.rs b/tests/io_uring/register.rs
diff --git a/tests/termios/isatty.rs b/tests/termios/isatty.rs

Original file line number	Diff line number	Diff line change
`@@ -294,6 +294,11 @@ impl<'a> Iterator for Iter<'a> {`
`294`	`294`	`fn next(&mut self) -> Option<Self::Item> {`
`295`	`295`	`self.iter.next()`
`296`	`296`	`}`
	`297`	`+`
	`298`	`+ #[inline]`
	`299`	`+ fn size_hint(&self) -> (usize, Option<usize>) {`
	`300`	`+ self.iter.size_hint()`
	`301`	`+ }`
`297`	`302`	`}`
`298`	`303`
`299`	`304`	`/// A record of an event that occurred.`
Original file line number	Diff line number	Diff line change
`@@ -194,16 +194,16 @@ impl Hash for SocketAddrUnix {`
`194`	`194`
`195`	`195`	`#[cfg(unix)]`
`196`	`196`	`impl fmt::Debug for SocketAddrUnix {`
`197`		`- fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {`
	`197`	`+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {`
`198`	`198`	`if let Some(path) = self.path() {`
`199`		`- path.fmt(fmt)`
	`199`	`+ path.fmt(f)`
`200`	`200`	`} else {`
`201`	`201`	`#[cfg(linux_kernel)]`
`202`	`202`	`if let Some(name) = self.abstract_name() {`
`203`		`- return name.fmt(fmt);`
	`203`	`+ return name.fmt(f);`
`204`	`204`	`}`
`205`	`205`
`206`		`- "(unnamed)".fmt(fmt)`
	`206`	`+ "(unnamed)".fmt(f)`
`207`	`207`	`}`
`208`	`208`	`}`
`209`	`209`	`}`
Original file line number	Diff line number	Diff line change
`@@ -304,6 +304,11 @@ impl<'a> Iterator for Iter<'a> {`
`304`	`304`	`fn next(&mut self) -> Option<Self::Item> {`
`305`	`305`	`self.iter.next()`
`306`	`306`	`}`
	`307`	`+`
	`308`	`+ #[inline]`
	`309`	`+ fn size_hint(&self) -> (usize, Option<usize>) {`
	`310`	`+ self.iter.size_hint()`
	`311`	`+ }`
`307`	`312`	`}`
`308`	`313`
`309`	`314`	`/// A record of an event that occurred.`
Original file line number	Diff line number	Diff line change
`@@ -277,7 +277,7 @@ pub(crate) fn is_read_write(fd: BorrowedFd<'_>) -> io::Result<(bool, bool)> {`
`277`	`277`	`match unsafe {`
`278`	`278`	`crate::backend::net::syscalls::recv(`
`279`	`279`	`fd,`
`280`		`- buf.as_mut_ptr() as *mut u8,`
	`280`	`+ buf.as_mut_ptr().cast::<u8>(),`
`281`	`281`	`1,`
`282`	`282`	`RecvFlags::PEEK \| RecvFlags::DONTWAIT,`
`283`	`283`	`)`
Original file line number	Diff line number	Diff line change
`@@ -152,13 +152,13 @@ impl Hash for SocketAddrUnix {`
`152`	`152`	`}`
`153`	`153`
`154`	`154`	`impl fmt::Debug for SocketAddrUnix {`
`155`		`- fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {`
	`155`	`+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {`
`156`	`156`	`if let Some(path) = self.path() {`
`157`		`- path.fmt(fmt)`
	`157`	`+ path.fmt(f)`
`158`	`158`	`} else if let Some(name) = self.abstract_name() {`
`159`		`- name.fmt(fmt)`
	`159`	`+ name.fmt(f)`
`160`	`160`	`} else {`
`161`		`- "(unnamed)".fmt(fmt)`
	`161`	`+ "(unnamed)".fmt(f)`
`162`	`162`	`}`
`163`	`163`	`}`
`164`	`164`	`}`