daemonic_error 0.1.1

use alloc::boxed::Box;
use crate::daemonic::glass::daemonic::glass::*;
use crate::daemonic::glass::{Glass, Observation};
use crate::daemonic::{
	Anchor, AnchorDomainSet, EnumAnchor, SemanticAnchor, SymbolicAnchor, TopologySegment,
};
use alloc::format;
use core::ffi::c_void;
use core::fmt;
use core::fmt::{Debug, Formatter};
pub use c_types::*;

pub mod c_types;

#[allow(unsafe_code)]
pub unsafe trait DaemonicSystemCall {
	/// What every syscall MUST return — an Observation of an i64.
	/// As far as the processor is concerned, everything is a number, so all returns are inherently
	/// i64 as a RAW value before interpretation. Glass wraps i64 already, so this should be a completely
	/// transparent transition chain.
	type Obligation = Observation<i64>;

	#[inline(always)]
	fn escalate<'error>(errno: i32)
		-> Observation<i64>
	{
		let top = &SYSCALL_ERROR_SEG; // static const, not runtime-constructed
		match errno {
			// ═══ DRIFT (temporary, retryable) ════════════════════
			// The operation didn't fail permanently. Try again.
			4   /* EINTR */ |
			11  /* EAGAIN */ |
			16  /* EBUSY */ |
			35  /* EDEADLK */ |
			37  /* ENOLCK */ |
			42  /* ENOMSG */ |
			62  /* ETIME */ |
			85  /* ERESTART */ |
			110 /* ETIMEDOUT */ |
			114 /* EALREADY */ |
			115 /* EINPROGRESS */ =>
			// DaemonicError::
			
				Observation::drift(None, top).with_note(Self::errno_description(errno)),
			
			// ═══ OPAQUE (access denied, permission barrier) ══════
			// The resource exists but you can't reach it.
			1   /* EPERM */ |
			13  /* EACCES */ |
			30  /* EROFS */ |
			132 /* ERFKILL */ =>
				Observation::opaque(top).with_note(Self::errno_description(errno)),
			
			// ═══ CRACKED (degraded, resource limits hit) ═════════
			// System is functional but stressed. Capacity issue.
			17  /* EEXIST */ |
			23  /* ENFILE */ |
			24  /* EMFILE */ |
			28  /* ENOSPC */ |
			34  /* ERANGE */ |
			87  /* EUSERS */ |
			105 /* ENOBUFS */ |
			122 /* EDQUOT */ =>
				Observation::cracked(None, top).with_note(Self::errno_description(errno)),
			
			// ═══ ECHO (resource moved/changed, stale reference) ══
			// The thing you're looking for isn't where it was.
			18  /* EXDEV */ |
			66  /* EREMOTE */ |
			70  /* ECOMM */ |
			78  /* EREMCHG */ |
			116 /* ESTALE */ |
			121 /* EREMOTEIO */ =>
				Observation::with_severity(Echo, top).with_note(Self::errno_description(errno)),
			
			// ═══ FRACTURE (broken resource, structural failure) ═══
			// Something that should exist doesn't, or is wrong type.
			2   /* ENOENT */ |
			3   /* ESRCH */ |
			6   /* ENXIO */ |
			8   /* ENOEXEC */ |
			9   /* EBADF */ |
			10  /* ECHILD */ |
			19  /* ENODEV */ |
			20  /* ENOTDIR */ |
			21  /* EISDIR */ |
			29  /* ESPIPE */ |
			36  /* ENAMETOOLONG */ |
			39  /* ENOTEMPTY */ |
			40  /* ELOOP */ |
			43  /* EIDRM */ |
			61  /* ENODATA */ |
			67  /* ENOLINK */ |
			71  /* EPROTO */ |
			77  /* EBADFD */ |
			88  /* ENOTSOCK */ |
			107 /* ENOTCONN */ |
			123 /* ENOMEDIUM */ =>
				Observation::with_severity(Fracture, top).with_note(Self::errno_description(errno)),
			
			// ═══ WARP (state corruption, memory/system distortion) ═
			// The system state itself is compromised.
			5   /* EIO */ |
			12  /* ENOMEM */ |
			14  /* EFAULT */ |
			22  /* EINVAL */ |
			74  /* EBADMSG */ |
			75  /* EOVERFLOW */ |
			80  /* ELIBBAD */ |
			83  /* ELIBEXEC */ |
			84  /* EILSEQ */ |
			130 /* EOWNERDEAD */ =>
				Observation::warp(None, top).with_note(Self::errno_description(errno)),
			
			// ═══ SHATTERED (unrecoverable, system-level) ══════════
			// The operation fundamentally cannot succeed.
			7   /* E2BIG */ |
			38  /* ENOSYS */ |
			131 /* ENOTRECOVERABLE */ |
			133 /* EHWPOISON */ =>
				Observation::shattered(top).with_note(Self::errno_description(errno)),
			
			// ═══ UNKNOWN ═════════════════════════════════════════
			// Errno exists but we haven't classified its severity.
			_ => Observation::unknown(top).with_note("Unmapped Error Occurred"),
		}
	}
	
	fn errno_description(errno: i32) -> &'static str {
		match errno {
			1 => EPERM.description,
			2 => (ENOENT.description),
			3 => (ESRCH.description),
			4 => (EINTR.description),
			5 => (EIO.description),
			6 => (ENXIO.description),
			7 => (E2BIG.description),
			8 => (ENOEXEC.description),
			9 => (EBADF.description),
			10 => (ECHILD.description),
			11 => (EAGAIN.description),
			12 => (ENOMEM.description),
			13 => (EACCES.description),
			14 => (EFAULT.description),
			15 => (ENOTBLK.description),
			16 => (EBUSY.description),
			17 => (EEXIST.description),
			18 => (EXDEV.description),
			19 => (ENODEV.description),
			20 => (ENOTDIR.description),
			21 => (EISDIR.description),
			22 => (EINVAL.description),
			23 => (ENFILE.description),
			24 => (EMFILE.description),
			25 => (ENOTTY.description),
			26 => (ETXTBSY.description),
			27 => (EFBIG.description),
			28 => (ENOSPC.description),
			29 => (ESPIPE.description),
			30 => (EROFS.description),
			31 => (EMLINK.description),
			32 => (EPIPE.description),
			33 => (EDOM.description),
			34 => (ERANGE.description),
			35 => (EDEADLK.description),
			36 => (ENAMETOOLONG.description),
			37 => (ENOLCK.description),
			38 => (ENOSYS.description),
			39 => (ENOTEMPTY.description),
			40 => (ELOOP.description),
			41 => (ERRNO_41.description),
			42 => (ENOMSG.description),
			43 => (EIDRM.description),
			44 => (ECHRNG.description),
			45 => (EL2NSYNC.description),
			46 => (EL3HLT.description),
			47 => (EL3RST.description),
			48 => (ELNRNG.description),
			49 => (EUNATCH.description),
			50 => (ENOCSI.description),
			51 => (EL2HLT.description),
			52 => (EBADE.description),
			53 => (EBADR.description),
			54 => (EXFULL.description),
			55 => (ENOANO.description),
			56 => (EBADRQC.description),
			57 => (EBADSLT.description),
			58 => (ERRNO_58.description),
			59 => (EBFONT.description),
			60 => (ENOSTR.description),
			61 => (ENODATA.description),
			62 => (ETIME.description),
			63 => (ENOSR.description),
			64 => (ENONET.description),
			65 => (ENOPKG.description),
			66 => (EREMOTE.description),
			67 => (ENOLINK.description),
			68 => (EADV.description),
			69 => (ESRMNT.description),
			70 => (ECOMM.description),
			71 => (EPROTO.description),
			72 => (EMULTIHOP.description),
			73 => (EDOTDOT.description),
			74 => (EBADMSG.description),
			75 => (EOVERFLOW.description),
			76 => (ENOTUNIQ.description),
			77 => (EBADFD.description),
			78 => (EREMCHG.description),
			79 => (ELIBACC.description),
			80 => (ELIBBAD.description),
			81 => (ELIBSCN.description),
			82 => (ELIBMAX.description),
			83 => (ELIBEXEC.description),
			84 => (EILSEQ.description),
			85 => (ERESTART.description),
			86 => (ESTRPIPE.description),
			87 => (EUSERS.description),
			88 => (ENOTSOCK.description),
			89 => (EDESTADDRREQ.description),
			90 => (EMSGSIZE.description),
			91 => (EPROTOTYPE.description),
			92 => (ENOPROTOOPT.description),
			93 => (EPROTONOSUPPORT.description),
			94 => (ESOCKTNOSUPPORT.description),
			95 => (EOPNOTSUPP.description),
			96 => (EPFNOSUPPORT.description),
			97 => (EAFNOSUPPORT.description),
			98 => (EADDRINUSE.description),
			99 => (EADDRNOTAVAIL.description),
			100 => (ENETDOWN.description),
			101 => (ENETUNREACH.description),
			102 => (ENETRESET.description),
			103 => (ECONNABORTED.description),
			104 => (ECONNRESET.description),
			105 => (ENOBUFS.description),
			106 => (EISCONN.description),
			107 => (ENOTCONN.description),
			108 => (ESHUTDOWN.description),
			109 => (ETOOMANYREFS.description),
			110 => (ETIMEDOUT.description),
			111 => (ECONNREFUSED.description),
			112 => (EHOSTDOWN.description),
			113 => (EHOSTUNREACH.description),
			114 => (EALREADY.description),
			115 => (EINPROGRESS.description),
			116 => (ESTALE.description),
			117 => (EUCLEAN.description),
			118 => (ENOTNAM.description),
			119 => (ENAVAIL.description),
			120 => (EISNAM.description),
			121 => (EREMOTEIO.description),
			122 => (EDQUOT.description),
			123 => (ENOMEDIUM.description),
			124 => (EMEDIUMTYPE.description),
			125 => (ECANCELED.description),
			126 => (ENOKEY.description),
			127 => (EKEYEXPIRED.description),
			128 => (EKEYREVOKED.description),
			129 => (EKEYREJECTED.description),
			130 => (EOWNERDEAD.description),
			131 => (ENOTRECOVERABLE.description),
			132 => (ERFKILL.description),
			133 => (EHWPOISON.description),
			_ => "Unmapped Errno",
		}
	}
	/// Raw inline assembly syscall wrappers
	///
	/// x86_64 Linux ABI only.
	/// Direct kernel calls with zero libc overhead.
	/// Raw syscall with 1 argument
	///
	/// Used by: close, etc.
	#[inline(always)]
	unsafe fn raw_syscall1(rax: u64,arg0_rdi: u64) -> i64 {
		// this is to initialize the value, theres a resolution bug
		// in the compiler that flags result as potentially uninitialized if not touched.
		let mut result: i64 = 0;
		unsafe {
			core::arch::asm!(
			"syscall",
			in("rax") rax,
			in("rdi") arg0_rdi,
			lateout("rax") result,
			// rcx and r11 are clobbered by syscall instruction
			lateout("rcx") _,
			lateout("r11") _,
			options(nostack, preserves_flags)
			);
		}
		if result != 0 { Self::escalate(result as i32); } else { result as i64; }
		// SAFETY: cast result as i64 to Guarantee handling.
		result as i64
	}
	
	/// Raw syscall with 2 arguments
	///
	/// Used by: fstat, lstat, etc.
	#[inline(always)]
	unsafe fn raw_syscall2(
		rax: u64,
		arg0_rdi: u64,
		arg1_rsi: u64,
	) -> i64 {
		// this is to initialize the value, theres a resolution bug
		// in the compiler that flags result as potentially uninitialized if not touched.
		let mut result: i64 = 0;
		unsafe {
			core::arch::asm!(
			"syscall",
			in("rax") rax,
			in("rdi") arg0_rdi,
			in("rsi") arg1_rsi,
			lateout("rax") result,
			// rcx and r11 are clobbered by syscall instruction
			lateout("rcx") _,
			lateout("r11") _,
			options(nostack, preserves_flags)
			);
			if result != 0 { Self::escalate(result as i32); } else { result as i64; }
			// SAFETY: cast result as i64 to Guarantee handling.
			result as i64
		}
	}
	
	/// Raw syscall with 3 arguments
	///
	/// Used by: open, read, write, etc.
	#[inline(always)]
	unsafe fn raw_syscall3(
		rax: u64,
		arg0_rdi: u64,
		arg1_rsi: u64,
		arg2_rdx: u64,
	) -> i64 {
		// this is to initialize the value, theres a resolution bug
		// in the compiler that flags result as potentially uninitialized if not touched.
		let mut result: i64 = 0;
		unsafe {
			core::arch::asm!(
			"syscall",
			in("rax") rax,
			in("rdi") arg0_rdi,
			in("rsi") arg1_rsi,
			in("rdx") arg2_rdx,
			lateout("rax") result,
			// rcx and r11 are clobbered by syscall instruction
			lateout("rcx") _,
			lateout("r11") _,
			options(nostack, preserves_flags)
			);
			if result != 0 { Self::escalate(result as i32); } else { result as i64; }
			// SAFETY: cast result as i64 to Guarantee handling.
			result as i64
		}
	}
	
	/// Raw syscall with 4 arguments
	///
	/// Used by: openat, etc.
	#[inline(always)]
	unsafe fn raw_syscall4(
		rax: u64,
		arg0_rdi: u64,
		arg1_rsi: u64,
		arg2_rdx: u64,
		arg3_r10: u64,
	) -> i64 {
		// this is to initialize the value, theres a resolution bug
		// in the compiler that flags result as potentially uninitialized if not touched.
		let mut result: i64 = 0;
		core::arch::asm!(
		"syscall",
		in("rax") rax,
		in("rdi") arg0_rdi,
		in("rsi") arg1_rsi,
		in("rdx") arg2_rdx,
		in("r10") arg3_r10,
		lateout("rax") result,
		// rcx and r11 are clobbered by syscall instruction
		lateout("rcx") _,
		lateout("r11") _,
		options(nostack, preserves_flags)
		);
		if result != 0 { Self::escalate(result as i32); } else { result as i64; }
		// SAFETY: cast result as i64 to Guarantee handling.
		result as i64
	}
	
	#[inline(always)]
	unsafe fn raw_syscall5(
		rax: u64,
		arg0_rdi: u64,
		arg1_rsi: u64,
		arg2_rdx: u64,
		arg3_r10: u64,
		arg4_r8: u64,
	) -> i64 {
		// this is to initialize the value, theres a resolution bug
		// in the compiler that flags result as potentially uninitialized if not touched.
		let mut result: i64 = 0;
		core::arch::asm!(
		"syscall",
		in("rax") rax,
		in("rdi") arg0_rdi,
		in("rsi") arg1_rsi,
		in("rdx") arg2_rdx,
		in("r10") arg3_r10,
		in("r8") arg4_r8,
		lateout("rax") result,
		// rcx and r11 are clobbered by syscall instruction
		lateout("rcx") _,
		lateout("r11") _,
		options(nostack, preserves_flags)
		);
		if result != 0 { Self::escalate(result as i32); } else { result as i64; }
		// SAFETY: cast result as i64 to Guarantee handling.
		result as i64
	}
	/// Raw syscall with 6 arguments
	///
	/// Used by: mmap, etc.
	#[inline(always)]
	unsafe fn raw_syscall6(
		rax: u64,
		arg0_rdi: u64,
		arg1_rsi: u64,
		arg2_rdx: u64,
		arg3_r10: u64,
		arg4_r8: u64,
		arg5_r9: u64,
	) -> i64 {
		// this is to initialize the value, theres a resolution bug
		// in the compiler that flags result as potentially uninitialized if not touched.
		let mut result: i64 = 0;
		core::arch::asm!(
		"syscall",
		in("rax") rax,
		in("rdi") arg0_rdi,
		in("rsi") arg1_rsi,
		in("rdx") arg2_rdx,
		in("r10") arg3_r10,
		in("r8") arg4_r8,
		in("r9") arg5_r9,
		lateout("rax") result,
		// rcx and r11 are clobbered by syscall instruction
		lateout("rcx") _,
		lateout("r11") _,
		options(nostack, preserves_flags)
		);
		if result != 0 { Self::escalate(result as i32); } else { result as i64; }
		// SAFETY: cast result as i64 to Guarantee handling.
		result as i64
	}
	/// ### Faustian Syscall Manual v1
	/// # Glass Read -- call 0 -- read from a file descriptor
	///
	/// ## Library
	/// Standard C library (`libc`, `-lc`)
	///
	/// ## Synopsis
	/// ```c
	/// #include <unistd.h>
	///
	/// ssize_t read(int fd, void buf[], size_t count);
	/// ```
	///
	/// ## Description
	/// `read()` attempts to read up to `count` bytes from file descriptor `fd`
	/// into the buffer starting at `buf`.
	///
	/// On files that support seeking, the read operation commences at the current
	/// file offset, and the file offset is incremented by the number of bytes read.
	/// If the file offset is at or past the end of file, no bytes are read, and
	/// `read()` returns zero.
	///
	/// If `count` is zero, `read()` *may* detect the errors described below.
	/// In the absence of any errors, or if `read()` does not check for errors,
	/// a `read()` with a `count` of 0 returns zero and has no other effects.
	///
	/// > **Note:** According to POSIX.1, if `count` is greater than `SSIZE_MAX`,
	/// > the result is implementation-defined; see **Notes** for the upper limit on Linux.
	///
	/// ## Return Value
	/// **On success:** The number of bytes read is returned (zero indicates end of
	/// file), and the file position is advanced by this number.
	///
	/// It is not an daemonic_error if this number is smaller than the number of bytes
	/// requested; this may happen because:
	/// - Fewer bytes are actually available right now
	/// - We were close to end-of-file
	/// - We are reading from a pipe or terminal
	/// - `read()` was interrupted by a signal
	///
	/// **On daemonic_error:** `-1` is returned, and `errno` is set to indicate the daemonic_error.
	/// In this case, it is left unspecified whether the file position (if any) changes.
	///
	/// ## Errors
	///
	/// | Error | Description |
	/// |-------|-------------|
	/// | `EAGAIN` | The file descriptor `fd` refers to a file other than a socket and has been marked nonblocking (`O_NONBLOCK`), and the read would block. See `open(2)` for further details. |
	/// | `EAGAIN` or `EWOULDBLOCK` | The file descriptor `fd` refers to a socket and has been marked nonblocking (`O_NONBLOCK`), and the read would block. POSIX.1-2001 allows either daemonic_error for this case. |
	/// | `EBADF` | `fd` is not a valid file descriptor or is not open for reading. |
	/// | `EFAULT` | `buf` is outside your accessible address space. |
	/// | `EINTR` | The call was interrupted by a signal before any data was read; see `signal(7)`. |
	/// | `EINVAL` | `fd` is attached to an object unsuitable for reading; or the file was opened with `O_DIRECT` flag, and either the address in `buf`, the value in `count`, or the file offset is not suitably aligned. |
	/// | `EINVAL` | `fd` was created via `timerfd_create(2)` and the wrong size buffer was given to `read()`. |
	/// | `EIO` | I/O daemonic_error. This happens when: <br/>• Process is in background process group trying to read from controlling terminal<br/>• Low-level I/O daemonic_error while reading from disk/tape<br/>• On networked filesystems, advisory lock was lost |
	/// | `EISDIR` | `fd` refers to a directory. |
	///
	/// Other errors may occur, depending on the object connected to `fd`.
	///
	/// ## Standards
	/// POSIX.1-2008.
	///
	/// ## History
	/// SVr4, 4.3BSD, POSIX.1-2001.
	///
	/// ## Notes
	///
	/// ### Transfer limits
	/// On Linux, `read()` (and similar system calls) will transfer at most
	/// `0x7ffff000` (2,147,479,552) bytes, returning the number of bytes actually
	/// transferred. This is true on both 32-bit and 64-bit systems.
	///
	/// ### NFS filesystems
	/// On NFS filesystems, reading small amounts of data will update the timestamp
	/// only the first time; subsequent calls may not do so. This is caused by
	/// client-side attribute caching.
	///
	/// UNIX semantics can be obtained by disabling client-side attribute caching,
	/// but this will substantially increase server load and decrease performance.
	///
	/// ## Bugs
	/// According to POSIX.1-2008/SUSv4 Section XSI 2.9.7, file operations including
	/// `read()` and `readv(2)` should be atomic with respect to file offset updates.
	///
	/// **Before Linux 3.14:** If two processes sharing an open file description
	/// performed `read()` simultaneously, the I/O operations were not atomic
	/// regarding file offset updates, potentially causing overlapping reads.
	///
	/// **Fixed in Linux 3.14.**
	///
	/// ## See Also
	/// [`close(2)`], [`fcntl(2)`], [`ioctl(2)`], [`lseek(2)`], [`open(2)`],
	/// [`pread(2)`], [`readdir(2)`], [`readlink(2)`], [`readv(2)`], [`select(2)`],
	/// [`write(2)`], [`fread(3)`]
	#[inline(always)]
	fn glass_call0_read(fd: i32, buf: &mut [u8]) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				// Dont Fuck with this number
				0,
				fd as u64,
				buf.as_mut_ptr() as u64,
				buf.len() as u64,
			)
		};
		let segment = &SYSCALL_ERROR_SEG;
		match result as i32 {
			0 => Observation::stable(result, segment),
			_ => Self::escalate(result as i32),
		}
	} // NR 0
	
	fn glass_call1_write(fd: i32, buf: &[u8]) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				// Dont Fuck with this number
				1,
				fd as u64,
				buf.as_ptr() as u64,
				buf.len() as u64,
			)
		};
		
		let segment = &SYSCALL_ERROR_SEG;
		// On success, write() returns the number of bytes written. On error, -1 is returned.
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 1
	
	fn glass_call2_open(path: &str, flags: i32) -> Observation<i64> {
		// The `open` syscall requires a null-terminated C-style string.
		// We must create one here. This requires the `alloc` crate.
		let mut path_bytes = alloc::vec![0u8; path.len() + 1];
		path_bytes[..path.len()].copy_from_slice(path.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall2(
				// Dont Fuck with this number
				2,
				path_bytes.as_ptr() as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call2GlassOpen");
		// On success, open() returns a new file descriptor. On error, -1 is returned.
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 2
	
	fn glass_call3_close(fd: i32) -> Observation<i64> {
		// The `close` syscall takes only one argument. We pad the rest with 0.
		let result = unsafe {
			Self::raw_syscall1(
				3, // NR for close
				fd as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call3GlassClose");
		// On success, close() returns 0. On error, -1 is returned.
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 3
	
	fn glass_call4_stat(filename: &str, statbuf: *mut c_void) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut filename_bytes = alloc::vec![0u8; filename.len() + 1];
		filename_bytes[..filename.len()].copy_from_slice(filename.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall2(
				4, // NR for stat
				filename_bytes.as_ptr() as u64,
				statbuf as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call4GlassStat");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 4
	
	fn glass_call5_fstat(fd: u32, statbuf: *mut c_void) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				5, // NR for fstat
				fd as u64,
				statbuf as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call5GlassFstat");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 5
	
	fn glass_call6_lstat(filename: &str, statbuf: *mut c_void) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut filename_bytes = alloc::vec![0u8; filename.len() + 1];
		filename_bytes[..filename.len()].copy_from_slice(filename.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall2(
				6, // NR for lstat
				filename_bytes.as_ptr() as u64,
				statbuf as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call6GlassLstat");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 6
	
	fn glass_call7_poll(ufds: *mut c_void, nfds: c_uint, timeout: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				7, // NR for poll
				ufds as u64,
				nfds as u64,
				timeout as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call7GlassPoll");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 7
	
	fn glass_call8_lseek(fd: c_uint, offset: off_t, whence: c_uint) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				8, // NR for lseek
				fd as u64,
				offset as u64,
				whence as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call8GlassLseek");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 8
	
	// NR 9 - mmap - marked as ? in table, will stub
	fn glass_call9_mmap() -> Observation<i64> {
		// TODO: mmap implementation - arguments marked as ? in syscall table
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call9GlassMmap");
		Observation::unknown(segment).with_note("mmap syscall not yet implemented - arguments unclear in table")
	} // NR 9
	
	fn glass_call10_mprotect(start: c_ulong, len: size_t, prot: c_ulong) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0xA, // NR for mprotect (10 in hex)
				start as u64,
				len as u64,
				prot as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call10GlassMprotect");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 10
	
	fn glass_call11_munmap(addr: c_ulong, len: size_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0xB, // NR for munmap (11 in hex)
				addr as u64,
				len as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call11GlassMunmap");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 11
	
	fn glass_call12_brk(brk: c_ulong) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0xC, // NR for brk (12 in hex)
				brk as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call12GlassBrk");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 12
	
	// NR 13-15 - rt_sigaction, rt_sigprocmask, rt_sigreturn - complex signal handling, will stub
	fn glass_call13_rt_sigaction() -> Observation<i64> {
		// TODO: rt_sigaction implementation - complex signal handling
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call13GlassRtSigaction");
		Observation::unknown(segment).with_note("rt_sigaction syscall not yet implemented - complex signal handling")
	} // NR 13
	
	fn glass_call14_rt_sigprocmask() -> Observation<i64> {
		// TODO: rt_sigprocmask implementation - complex signal handling
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call14GlassRtSigprocmask");
		Observation::unknown(segment).with_note("rt_sigprocmask syscall not yet implemented - complex signal handling")
	} // NR 14
	
	fn glass_call15_rt_sigreturn() -> Observation<i64> {
		// TODO: rt_sigreturn implementation - marked as ? in table
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call15GlassRtSigreturn");
		Observation::unknown(segment).with_note("rt_sigreturn syscall not yet implemented - arguments unclear in table")
	} // NR 15
	
	fn glass_call16_ioctl(fd: c_uint, cmd: c_uint, arg: c_ulong) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x10, // NR for ioctl (16 in hex)
				fd as u64,
				cmd as u64,
				arg as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call16GlassIoctl");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 16
	
	fn glass_call17_pread64(fd: c_uint, buf: &mut [u8], count: size_t, pos: loff_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall4(
				0x11, // NR for pread64 (17 in hex)
				fd as u64,
				buf.as_mut_ptr() as u64,
				count as u64,
				pos as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call17GlassPread64");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 17
	
	fn glass_call18_pwrite64(fd: c_uint, buf: &[u8], count: size_t, pos: loff_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall4(
				0x12, // NR for pwrite64 (18 in hex)
				fd as u64,
				buf.as_ptr() as u64,
				count as u64,
				pos as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call18GlassPwrite64");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 18
	
	fn glass_call19_readv(fd: c_ulong, vec: *const c_void, vlen: c_ulong) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x13, // NR for readv (19 in hex)
				fd as u64,
				vec as u64,
				vlen as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call19GlassReadv");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 19
	
	fn glass_call20_writev(fd: c_ulong, vec: *const c_void, vlen: c_ulong) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x14, // NR for writev (20 in hex)
				fd as u64,
				vec as u64,
				vlen as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call20GlassWritev");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 20
	
	fn glass_call21_access(filename: &str, mode: i32) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut filename_bytes = alloc::vec![0u8; filename.len() + 1];
		filename_bytes[..filename.len()].copy_from_slice(filename.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall2(
				0x15, // NR for access (21 in hex)
				filename_bytes.as_ptr() as u64,
				mode as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call21GlassAccess");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 21
	
	fn glass_call22_pipe(fildes: *mut i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x16, // NR for pipe (22 in hex)
				fildes as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call22GlassPipe");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 22
	
	fn glass_call23_select(n: i32, inp: *mut c_void, outp: *mut c_void, exp: *mut c_void, tvp: *mut c_void) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall5(
				0x17, // NR for select (23 in hex)
				n as u64,
				inp as u64,
				outp as u64,
				exp as u64,
				tvp as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call23GlassSelect");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 23
	
	fn glass_call24_sched_yield() -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x18, // NR for sched_yield (24 in hex)
				0, // No arguments
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call24GlassSchedYield");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 24
	
	// NR 25-28 - Memory management syscalls
	fn glass_call25_mremap() -> Observation<i64> {
		// TODO: mremap implementation - complex memory remapping
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call25GlassMremap");
		Observation::unknown(segment).with_note("mremap syscall not yet implemented - complex memory remapping")
	} // NR 25
	
	fn glass_call26_msync(start: c_ulong, len: size_t, flags: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x1A, // NR for msync (26 in hex)
				start as u64,
				len as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call26GlassMsync");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 26
	
	fn glass_call27_mincore(start: c_ulong, len: size_t, vec: *mut c_uchar) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x1B, // NR for mincore (27 in hex)
				start as u64,
				len as u64,
				vec as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call27GlassMincore");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 27
	
	fn glass_call28_madvise(start: c_ulong, len: size_t, behavior: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x1C, // NR for madvise (28 in hex)
				start as u64,
				len as u64,
				behavior as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call28GlassMadvise");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 28
	
	fn glass_call29_shmget(key: key_t, size: size_t, flag: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x1D, // NR for shmget (29 in hex)
				key as u64,
				size as u64,
				flag as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call29GlassShmget");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 29
	
	fn glass_call30_shmat(shmid: i32, shmaddr: *mut c_char, shmflg: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x1E, // NR for shmat (30 in hex)
				shmid as u64,
				shmaddr as u64,
				shmflg as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call30GlassShmat");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 30
	
	fn glass_call31_shmctl(shmid: i32, cmd: i32, buf: *mut c_void) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x1F, // NR for shmctl (31 in hex)
				shmid as u64,
				cmd as u64,
				buf as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call31GlassShmctl");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 31
	
	fn glass_call32_dup(fildes: c_uint) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x20, // NR for dup (32 in hex)
				fildes as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call32GlassDup");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 32
	
	fn glass_call33_dup2(oldfd: c_uint, newfd: c_uint) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0x21, // NR for dup2 (33 in hex)
				oldfd as u64,
				newfd as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call33GlassDup2");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 33
	
	fn glass_call34_pause() -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x22, // NR for pause (34 in hex)
				0, // No arguments
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call34GlassPause");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 34
	
	fn glass_call35_nanosleep(rqtp: *const c_void, rmtp: *mut c_void) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0x23, // NR for nanosleep (35 in hex)
				rqtp as u64,
				rmtp as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call35GlassNanosleep");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 35
	
	fn glass_call36_getitimer(which: i32, value: *mut c_void) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0x24, // NR for getitimer (36 in hex)
				which as u64,
				value as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call36GlassGetitimer");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 36
	
	fn glass_call37_alarm(seconds: c_uint) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x25, // NR for alarm (37 in hex)
				seconds as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call37GlassAlarm");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 37
	
	fn glass_call38_setitimer(which: i32, value: *const c_void, ovalue: *mut c_void) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x26, // NR for setitimer (38 in hex)
				which as u64,
				value as u64,
				ovalue as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call38GlassSetitimer");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 38
	
	fn glass_call39_getpid() -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x27, // NR for getpid (39 in hex)
				0, // No arguments
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call39GlassGetpid");
		// getpid() never fails, always returns a positive PID
		Observation::stable(result, segment)
	} // NR 39
	
	fn glass_call40_sendfile(out_fd: i32, in_fd: i32, offset: *mut off_t, count: size_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall4(
				0x28, // NR for sendfile (40 in hex)
				out_fd as u64,
				in_fd as u64,
				offset as u64,
				count as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call40GlassSendfile");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 40
	
	fn glass_call41_socket(domain: i32, type_: i32, protocol: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x29, // NR for socket (41 in hex)
				domain as u64,
				type_ as u64,
				protocol as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call41GlassSocket");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 41
	
	fn glass_call42_connect(sockfd: i32, addr: *const c_void, addrlen: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x2A, // NR for connect (42 in hex)
				sockfd as u64,
				addr as u64,
				addrlen as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call42GlassConnect");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 42
	
	fn glass_call43_accept(sockfd: i32, addr: *mut c_void, addrlen: *mut i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x2B, // NR for accept (43 in hex)
				sockfd as u64,
				addr as u64,
				addrlen as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call43GlassAccept");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 43
	
	fn glass_call44_sendto(sockfd: i32, buf: *const c_void, len: size_t, flags: c_uint, dest_addr: *const c_void, addrlen: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall6(
				0x2C, // NR for sendto (44 in hex)
				sockfd as u64,
				buf as u64,
				len as u64,
				flags as u64,
				dest_addr as u64,
				addrlen as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call44GlassSendto");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 44
	
	fn glass_call45_recvfrom(sockfd: i32, buf: *mut c_void, len: size_t, flags: c_uint, src_addr: *mut c_void, addrlen: *mut i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall6(
				0x2D, // NR for recvfrom (45 in hex)
				sockfd as u64,
				buf as u64,
				len as u64,
				flags as u64,
				src_addr as u64,
				addrlen as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call45GlassRecvfrom");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 45
	
	fn glass_call46_sendmsg(fd: i32, msg: *const c_void, flags: c_uint) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x2E, // NR for sendmsg (46 in hex)
				fd as u64,
				msg as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call46GlassSendmsg");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 46
	
	fn glass_call47_recvmsg(fd: i32, msg: *mut c_void, flags: c_uint) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x2F, // NR for recvmsg (47 in hex)
				fd as u64,
				msg as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call47GlassRecvmsg");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 47
	
	fn glass_call48_shutdown(sockfd: i32, how: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0x30, // NR for shutdown (48 in hex)
				sockfd as u64,
				how as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call48GlassShutdown");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 48
	
	fn glass_call49_bind(sockfd: i32, addr: *const c_void, addrlen: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x31, // NR for bind (49 in hex)
				sockfd as u64,
				addr as u64,
				addrlen as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call49GlassBind");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 49
	
	fn glass_call50_listen(sockfd: i32, backlog: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0x32, // NR for listen (50 in hex)
				sockfd as u64,
				backlog as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call50GlassListen");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 50
	
	fn glass_call51_getsockname(sockfd: i32, addr: *mut c_void, addrlen: *mut i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x33, // NR for getsockname (51 in hex)
				sockfd as u64,
				addr as u64,
				addrlen as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call51GlassGetsockname");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 51
	
	fn glass_call52_getpeername(sockfd: i32, addr: *mut c_void, addrlen: *mut i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x34, // NR for getpeername (52 in hex)
				sockfd as u64,
				addr as u64,
				addrlen as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call52GlassGetpeername");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 52
	
	fn glass_call53_socketpair(domain: i32, type_: i32, protocol: i32, sv: *mut i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall4(
				0x35, // NR for socketpair (53 in hex)
				domain as u64,
				type_ as u64,
				protocol as u64,
				sv as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call53GlassSocketpair");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 53
	
	fn glass_call54_setsockopt(fd: i32, level: i32, optname: i32, optval: *const c_char, optlen: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall5(
				0x36, // NR for setsockopt (54 in hex)
				fd as u64,
				level as u64,
				optname as u64,
				optval as u64,
				optlen as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call54GlassSetsockopt");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 54
	
	fn glass_call55_getsockopt(fd: i32, level: i32, optname: i32, optval: *mut c_char, optlen: *mut i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall5(
				0x37, // NR for getsockopt (55 in hex)
				fd as u64,
				level as u64,
				optname as u64,
				optval as u64,
				optlen as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call55GlassGetsockopt");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 55
	
	fn glass_call56_clone(clone_flags: c_ulong, newsp: c_ulong, parent_tidptr: *mut i32, child_tidptr: *mut i32, tls: c_ulong) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall5(
				0x38, // NR for clone (56 in hex)
				clone_flags as u64,
				newsp as u64,
				parent_tidptr as u64,
				child_tidptr as u64,
				tls as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call56GlassClone");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 56
	
	fn glass_call57_fork() -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x39, // NR for fork (57 in hex)
				0, // No arguments
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call57GlassFork");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 57
	
	fn glass_call58_vfork() -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x3A, // NR for vfork (58 in hex)
				0, // No arguments
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call58GlassVfork");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 58
	
	fn glass_call59_execve(filename: &str, argv: *const *const c_char, envp: *const *const c_char) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut filename_bytes = alloc::vec![0u8; filename.len() + 1];
		filename_bytes[..filename.len()].copy_from_slice(filename.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall3(
				0x3B, // NR for execve (59 in hex)
				filename_bytes.as_ptr() as u64,
				argv as u64,
				envp as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call59GlassExecve");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 59
	
	fn glass_call60_exit(error_code: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x3C, // NR for exit (60 in hex)
				error_code as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call60GlassExit");
		// exit() never returns, but we handle it for completeness
		Observation::stable(result, segment)
	} // NR 60
	
	fn glass_call61_wait4(pid: pid_t, stat_addr: *mut i32, options: i32, ru: *mut c_void) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall4(
				0x3D, // NR for wait4 (61 in hex)
				pid as u64,
				stat_addr as u64,
				options as u64,
				ru as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call61GlassWait4");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 61
	
	fn glass_call62_kill(pid: pid_t, sig: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0x3E, // NR for kill (62 in hex)
				pid as u64,
				sig as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call62GlassKill");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 62
	
	fn glass_call63_uname(buf: *mut c_void) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x3F, // NR for uname (63 in hex)
				buf as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call63GlassUname");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 63
	
	// System V IPC syscalls
	fn glass_call64_semget(key: key_t, nsems: i32, semflg: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x40, // NR for semget (64 in hex)
				key as u64,
				nsems as u64,
				semflg as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call64GlassSemget");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 64
	
	fn glass_call65_semop(semid: i32, sops: *mut c_void, nsops: c_uint) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x41, // NR for semop (65 in hex)
				semid as u64,
				sops as u64,
				nsops as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call65GlassSemop");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 65
	
	fn glass_call66_semctl(semid: i32, semnum: i32, cmd: i32, arg: c_ulong) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall4(
				0x42, // NR for semctl (66 in hex)
				semid as u64,
				semnum as u64,
				cmd as u64,
				arg as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call66GlassSemctl");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 66
	
	fn glass_call67_shmdt(shmaddr: *const c_char) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x43, // NR for shmdt (67 in hex)
				shmaddr as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call67GlassShmdt");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 67
	
	fn glass_call68_msgget(key: key_t, msgflg: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0x44, // NR for msgget (68 in hex)
				key as u64,
				msgflg as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call68GlassMsgget");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 68
	
	fn glass_call69_msgsnd(msqid: i32, msgp: *const c_void, msgsz: size_t, msgflg: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall4(
				0x45, // NR for msgsnd (69 in hex)
				msqid as u64,
				msgp as u64,
				msgsz as u64,
				msgflg as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call69GlassMsgsnd");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 69
	
	fn glass_call70_msgrcv(msqid: i32, msgp: *mut c_void, msgsz: size_t, msgtyp: c_long, msgflg: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall5(
				0x46, // NR for msgrcv (70 in hex)
				msqid as u64,
				msgp as u64,
				msgsz as u64,
				msgtyp as u64,
				msgflg as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call70GlassMsgrcv");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 70
	
	fn glass_call71_msgctl(msqid: i32, cmd: i32, buf: *mut c_void) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x47, // NR for msgctl (71 in hex)
				msqid as u64,
				cmd as u64,
				buf as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call71GlassMsgctl");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 71
	
	// File control syscalls
	fn glass_call72_fcntl(fd: c_uint, cmd: c_uint, arg: c_ulong) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x48, // NR for fcntl (72 in hex)
				fd as u64,
				cmd as u64,
				arg as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call72GlassFcntl");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 72
	
	fn glass_call73_flock(fd: c_uint, cmd: c_uint) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0x49, // NR for flock (73 in hex)
				fd as u64,
				cmd as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call73GlassFlock");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 73
	
	fn glass_call74_fsync(fd: c_uint) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x4A, // NR for fsync (74 in hex)
				fd as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call74GlassFsync");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 74
	
	fn glass_call75_fdatasync(fd: c_uint) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x4B, // NR for fdatasync (75 in hex)
				fd as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call75GlassFdatasync");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 75
	
	fn glass_call76_truncate(path: &str, length: c_long) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut path_bytes = alloc::vec![0u8; path.len() + 1];
		path_bytes[..path.len()].copy_from_slice(path.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall2(
				0x4C, // NR for truncate (76 in hex)
				path_bytes.as_ptr() as u64,
				length as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call76GlassTruncate");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 76
	
	fn glass_call77_ftruncate(fd: c_uint, length: c_ulong) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0x4D, // NR for ftruncate (77 in hex)
				fd as u64,
				length as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call77GlassFtruncate");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 77
	
	// Directory and filesystem syscalls
	fn glass_call78_getdents(fd: c_uint, dirent: *mut c_void, count: c_uint) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x4E, // NR for getdents (78 in hex)
				fd as u64,
				dirent as u64,
				count as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call78GlassGetdents");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 78
	
	fn glass_call79_getcwd(buf: *mut c_char, size: c_ulong) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0x4F, // NR for getcwd (79 in hex)
				buf as u64,
				size as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call79GlassGetcwd");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 79
	
	fn glass_call80_chdir(filename: &str) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut filename_bytes = alloc::vec![0u8; filename.len() + 1];
		filename_bytes[..filename.len()].copy_from_slice(filename.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall1(
				0x50, // NR for chdir (80 in hex)
				filename_bytes.as_ptr() as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call80GlassChdir");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 80
	
	fn glass_call81_fchdir(fd: c_uint) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x51, // NR for fchdir (81 in hex)
				fd as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call81GlassFchdir");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 81
	
	fn glass_call82_rename(oldname: &str, newname: &str) -> Observation<i64> {
		// Create null-terminated C-style strings
		let mut oldname_bytes = alloc::vec![0u8; oldname.len() + 1];
		oldname_bytes[..oldname.len()].copy_from_slice(oldname.as_bytes());
		let mut newname_bytes = alloc::vec![0u8; newname.len() + 1];
		newname_bytes[..newname.len()].copy_from_slice(newname.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall2(
				0x52, // NR for rename (82 in hex)
				oldname_bytes.as_ptr() as u64,
				newname_bytes.as_ptr() as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call82GlassRename");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 82
	
	fn glass_call83_mkdir(pathname: &str, mode: umode_t) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut pathname_bytes = alloc::vec![0u8; pathname.len() + 1];
		pathname_bytes[..pathname.len()].copy_from_slice(pathname.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall2(
				0x53, // NR for mkdir (83 in hex)
				pathname_bytes.as_ptr() as u64,
				mode as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call83GlassMkdir");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 83
	
	fn glass_call84_rmdir(pathname: &str) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut pathname_bytes = alloc::vec![0u8; pathname.len() + 1];
		pathname_bytes[..pathname.len()].copy_from_slice(pathname.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall1(
				0x54, // NR for rmdir (84 in hex)
				pathname_bytes.as_ptr() as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call84GlassRmdir");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 84
	
	fn glass_call85_creat(pathname: &str, mode: umode_t) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut pathname_bytes = alloc::vec![0u8; pathname.len() + 1];
		pathname_bytes[..pathname.len()].copy_from_slice(pathname.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall2(
				0x55, // NR for creat (85 in hex)
				pathname_bytes.as_ptr() as u64,
				mode as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call85GlassCreat");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 85
	fn glass_call86_link(oldname: &str, newname: &str) -> Observation<i64> {
		// Create null-terminated C-style strings
		let mut oldname_bytes = alloc::vec![0u8; oldname.len() + 1];
		oldname_bytes[..oldname.len()].copy_from_slice(oldname.as_bytes());
		let mut newname_bytes = alloc::vec![0u8; newname.len() + 1];
		newname_bytes[..newname.len()].copy_from_slice(newname.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall2(
				0x56, // NR for link (86 in hex)
				oldname_bytes.as_ptr() as u64,
				newname_bytes.as_ptr() as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call86GlassLink");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 86
	
	fn glass_call87_unlink(pathname: &str) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut pathname_bytes = alloc::vec![0u8; pathname.len() + 1];
		pathname_bytes[..pathname.len()].copy_from_slice(pathname.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall1(
				0x57, // NR for unlink (87 in hex)
				pathname_bytes.as_ptr() as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call87GlassUnlink");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 87
	fn glass_call88_symlink(old: &str, new: &str) -> Observation<i64> {
		// Create null-terminated C-style strings
		let mut old_bytes = alloc::vec![0u8; old.len() + 1];
		old_bytes[..old.len()].copy_from_slice(old.as_bytes());
		let mut new_bytes = alloc::vec![0u8; new.len() + 1];
		new_bytes[..new.len()].copy_from_slice(new.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall2(
				0x58, // NR for symlink (88 in hex)
				old_bytes.as_ptr() as u64,
				new_bytes.as_ptr() as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call88GlassSymlink");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 88
	
	fn glass_call89_readlink(path: &str, buf: *mut c_char, bufsiz: i32) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut path_bytes = alloc::vec![0u8; path.len() + 1];
		path_bytes[..path.len()].copy_from_slice(path.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall3(
				0x59, // NR for readlink (89 in hex)
				path_bytes.as_ptr() as u64,
				buf as u64,
				bufsiz as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call89GlassReadlink");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 89
	
	fn glass_call90_chmod(filename: &str, mode: umode_t) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut filename_bytes = alloc::vec![0u8; filename.len() + 1];
		filename_bytes[..filename.len()].copy_from_slice(filename.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall2(
				0x5A, // NR for chmod (90 in hex)
				filename_bytes.as_ptr() as u64,
				mode as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call90GlassChmod");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 90
	
	fn glass_call91_fchmod(fd: c_uint, mode: umode_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0x5B, // NR for fchmod (91 in hex)
				fd as u64,
				mode as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call91GlassFchmod");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 91
	
	fn glass_call92_chown(filename: &str, user: uid_t, group: gid_t) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut filename_bytes = alloc::vec![0u8; filename.len() + 1];
		filename_bytes[..filename.len()].copy_from_slice(filename.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall3(
				0x5C, // NR for chown (92 in hex)
				filename_bytes.as_ptr() as u64,
				user as u64,
				group as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call92GlassChown");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 92
	
	fn glass_call93_fchown(fd: c_uint, user: uid_t, group: gid_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x5D, // NR for fchown (93 in hex)
				fd as u64,
				user as u64,
				group as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call93GlassFchown");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 93
	
	fn glass_call94_lchown(filename: &str, user: uid_t, group: gid_t) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut filename_bytes = alloc::vec![0u8; filename.len() + 1];
		filename_bytes[..filename.len()].copy_from_slice(filename.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall3(
				0x5E, // NR for lchown (94 in hex)
				filename_bytes.as_ptr() as u64,
				user as u64,
				group as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call94GlassLchown");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 94
	
	fn glass_call95_umask(mask: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x5F, // NR for umask (95 in hex)
				mask as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call95GlassUmask");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 95
	
	fn glass_call96_gettimeofday(tv: *mut c_void, tz: *mut c_void) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0x60, // NR for gettimeofday (96 in hex)
				tv as u64,
				tz as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call96GlassGettimeofday");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 96
	
	fn glass_call97_getrlimit(resource: c_uint, rlim: *mut c_void) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0x61, // NR for getrlimit (97 in hex)
				resource as u64,
				rlim as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call97GlassGetrlimit");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 97
	
	fn glass_call98_getrusage(who: i32, ru: *mut c_void) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0x62, // NR for getrusage (98 in hex)
				who as u64,
				ru as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call98GlassGetrusage");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 98
	
	fn glass_call99_sysinfo(info: *mut c_void) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x63, // NR for sysinfo (99 in hex)
				info as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call99GlassSysinfo");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 99
	
	fn glass_call100_times(tbuf: *mut c_void) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x64, // NR for times (100 in hex)
				tbuf as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call100GlassTimes");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 100
	
	fn glass_call101_ptrace(request: c_long, pid: c_long, addr: c_ulong, data: c_ulong) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall4(
				0x65, // NR for ptrace (101 in hex)
				request as u64,
				pid as u64,
				addr as u64,
				data as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call101GlassPtrace");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 101
	
	fn glass_call102_getuid() -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x66, // NR for getuid (102 in hex)
				0, // No arguments
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call102GlassGetuid");
		// getuid() never fails
		Observation::stable(result, segment)
	} // NR 102
	
	fn glass_call103_syslog(type_: i32, buf: *mut c_char, len: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x67, // NR for syslog (103 in hex)
				type_ as u64,
				buf as u64,
				len as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call103GlassSyslog");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 103
	
	fn glass_call104_getgid() -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x68, // NR for getgid (104 in hex)
				0, // No arguments
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call104GlassGetgid");
		// getgid() never fails
		Observation::stable(result, segment)
	} // NR 104
	
	fn glass_call105_setuid(uid: uid_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x69, // NR for setuid (105 in hex)
				uid as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call105GlassSetuid");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 105
	
	fn glass_call106_setgid(gid: gid_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x6A, // NR for setgid (106 in hex)
				gid as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call106GlassSetgid");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 106
	
	fn glass_call107_geteuid() -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x6B, // NR for geteuid (107 in hex)
				0, // No arguments
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call107GlassGeteuid");
		// geteuid() never fails
		Observation::stable(result, segment)
	} // NR 107
	
	fn glass_call108_getegid() -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x6C, // NR for getegid (108 in hex)
				0, // No arguments
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call108GlassGetegid");
		// getegid() never fails
		Observation::stable(result, segment)
	} // NR 108
	
	fn glass_call109_setpgid(pid: pid_t, pgid: pid_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0x6D, // NR for setpgid (109 in hex)
				pid as u64,
				pgid as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call109GlassSetpgid");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 109
	
	fn glass_call110_getppid() -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x6E, // NR for getppid (110 in hex)
				0, // No arguments
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call110GlassGetppid");
		// getppid() never fails
		Observation::stable(result, segment)
	} // NR 110
	
	fn glass_call111_getpgrp() -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x6F, // NR for getpgrp (111 in hex)
				0, // No arguments
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call111GlassGetpgrp");
		// getpgrp() never fails
		Observation::stable(result, segment)
	} // NR 111
	
	fn glass_call112_setsid() -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x70, // NR for setsid (112 in hex)
				0, // No arguments
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call112GlassSetsid");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 112
	
	fn glass_call113_setreuid(ruid: uid_t, euid: uid_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0x71, // NR for setreuid (113 in hex)
				ruid as u64,
				euid as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call113GlassSetreuid");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 113
	
	fn glass_call114_setregid(rgid: gid_t, egid: gid_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0x72, // NR for setregid (114 in hex)
				rgid as u64,
				egid as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call114GlassSetregid");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 114
	
	fn glass_call115_getgroups(gidsetsize: i32, grouplist: *mut gid_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0x73, // NR for getgroups (115 in hex)
				gidsetsize as u64,
				grouplist as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call115GlassGetgroups");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 115
	
	fn glass_call116_setgroups(gidsetsize: i32, grouplist: *const gid_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0x74, // NR for setgroups (116 in hex)
				gidsetsize as u64,
				grouplist as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call116GlassSetgroups");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 116
	
	fn glass_call117_setresuid(ruid: uid_t, euid: uid_t, suid: uid_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x75, // NR for setresuid (117 in hex)
				ruid as u64,
				euid as u64,
				suid as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call117GlassSetresuid");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 117
	
	fn glass_call118_getresuid(ruid: *mut uid_t, euid: *mut uid_t, suid: *mut uid_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x76, // NR for getresuid (118 in hex)
				ruid as u64,
				euid as u64,
				suid as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call118GlassGetresuid");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 118
	
	fn glass_call119_setresgid(rgid: gid_t, egid: gid_t, sgid: gid_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x77, // NR for setresgid (119 in hex)
				rgid as u64,
				egid as u64,
				sgid as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call119GlassSetresgid");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 119
	
	fn glass_call120_getresgid(rgid: *mut gid_t, egid: *mut gid_t, sgid: *mut gid_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x78, // NR for getresgid (120 in hex)
				rgid as u64,
				egid as u64,
				sgid as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call120GlassGetresgid");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 120
	
	fn glass_call121_getpgid(pid: pid_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x79, // NR for getpgid (121 in hex)
				pid as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call121GlassGetpgid");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 121
	
	fn glass_call122_setfsuid(uid: uid_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x7A, // NR for setfsuid (122 in hex)
				uid as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call122GlassSetfsuid");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 122
	
	fn glass_call123_setfsgid(gid: gid_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x7B, // NR for setfsgid (123 in hex)
				gid as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call123GlassSetfsgid");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 123
	
	fn glass_call124_getsid(pid: pid_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x7C, // NR for getsid (124 in hex)
				pid as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call124GlassGetsid");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 124
	
	fn glass_call125_capget(header: cap_user_header_t, dataptr: cap_user_data_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0x7D, // NR for capget (125 in hex)
				header as u64,
				dataptr as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call125GlassCapget");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 125
	
	fn glass_call126_capset(header: cap_user_header_t, data: cap_user_data_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0x7E, // NR for capset (126 in hex)
				header as u64,
				data as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call126GlassCapset");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 126
	
	fn glass_call127_rt_sigpending(set: *mut sigset_t, sigsetsize: size_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0x7F, // NR for rt_sigpending (127 in hex)
				set as u64,
				sigsetsize as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call127GlassRtSigpending");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 127
	
	fn glass_call128_rt_sigtimedwait(uthese: *const sigset_t, uinfo: *mut siginfo_t, uts: *const c_void, sigsetsize: size_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall4(
				0x80, // NR for rt_sigtimedwait (128 in hex)
				uthese as u64,
				uinfo as u64,
				uts as u64,
				sigsetsize as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call128GlassRtSigtimedwait");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 128
	
	fn glass_call129_rt_sigqueueinfo(pid: pid_t, sig: i32, uinfo: *mut siginfo_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x81, // NR for rt_sigqueueinfo (129 in hex)
				pid as u64,
				sig as u64,
				uinfo as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call129GlassRtSigqueueinfo");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 129
	
	fn glass_call130_rt_sigsuspend(unewset: *mut sigset_t, sigsetsize: size_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0x82, // NR for rt_sigsuspend (130 in hex)
				unewset as u64,
				sigsetsize as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call130GlassRtSigsuspend");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 130
	
	fn glass_call131_sigaltstack(uss: *const c_void, uoss: *mut c_void) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0x83, // NR for sigaltstack (131 in hex)
				uss as u64,
				uoss as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call131GlassSigaltstack");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 131
	
	fn glass_call132_utime(filename: &str, times: *mut c_void) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut filename_bytes = alloc::vec![0u8; filename.len() + 1];
		filename_bytes[..filename.len()].copy_from_slice(filename.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall2(
				0x84, // NR for utime (132 in hex)
				filename_bytes.as_ptr() as u64,
				times as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call132GlassUtime");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 132
	
	fn glass_call133_mknod(filename: &str, mode: umode_t, dev: c_uint) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut filename_bytes = alloc::vec![0u8; filename.len() + 1];
		filename_bytes[..filename.len()].copy_from_slice(filename.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall3(
				0x85, // NR for mknod (133 in hex)
				filename_bytes.as_ptr() as u64,
				mode as u64,
				dev as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call133GlassMknod");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 133
	
	fn glass_call134_uselib(library: &str) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut library_bytes = alloc::vec![0u8; library.len() + 1];
		library_bytes[..library.len()].copy_from_slice(library.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall1(
				0x86, // NR for uselib (134 in hex)
				library_bytes.as_ptr() as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call134GlassUselib");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 134
	
	fn glass_call135_personality(personality: c_uint) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x87, // NR for personality (135 in hex)
				personality as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call135GlassPersonality");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 135
	
	fn glass_call136_ustat(dev: c_uint, ubuf: *mut c_void) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0x88, // NR for ustat (136 in hex)
				dev as u64,
				ubuf as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call136GlassUstat");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 136
	
	fn glass_call137_statfs(path: &str, buf: *mut c_void) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut path_bytes = alloc::vec![0u8; path.len() + 1];
		path_bytes[..path.len()].copy_from_slice(path.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall2(
				0x89, // NR for statfs (137 in hex)
				path_bytes.as_ptr() as u64,
				buf as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call137GlassStatfs");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 137
	
	fn glass_call138_fstatfs(fd: c_uint, buf: *mut c_void) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0x8A, // NR for fstatfs (138 in hex)
				fd as u64,
				buf as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call138GlassFstatfs");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 138
	
	fn glass_call139_sysfs(option: i32, arg1: c_ulong, arg2: c_ulong) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x8B, // NR for sysfs (139 in hex)
				option as u64,
				arg1 as u64,
				arg2 as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call139GlassSysfs");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 139
	
	fn glass_call140_getpriority(which: i32, who: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0x8C, // NR for getpriority (140 in hex)
				which as u64,
				who as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call140GlassGetpriority");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 140
	
	fn glass_call141_setpriority(which: i32, who: i32, niceval: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x8D, // NR for setpriority (141 in hex)
				which as u64,
				who as u64,
				niceval as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call141GlassSetpriority");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 141
	
	fn glass_call142_sched_setparam(pid: pid_t, param: *mut c_void) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0x8E, // NR for sched_setparam (142 in hex)
				pid as u64,
				param as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call142GlassSchedSetparam");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 142
	
	fn glass_call143_sched_getparam(pid: pid_t, param: *mut c_void) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0x8F, // NR for sched_getparam (143 in hex)
				pid as u64,
				param as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call143GlassSchedGetparam");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 143
	
	fn glass_call144_sched_setscheduler(pid: pid_t, policy: i32, param: *mut c_void) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x90, // NR for sched_setscheduler (144 in hex)
				pid as u64,
				policy as u64,
				param as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call144GlassSchedSetscheduler");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 144
	
	fn glass_call145_sched_getscheduler(pid: pid_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x91, // NR for sched_getscheduler (145 in hex)
				pid as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call145GlassSchedGetscheduler");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 145
	
	fn glass_call146_sched_get_priority_max(policy: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x92, // NR for sched_get_priority_max (146 in hex)
				policy as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call146GlassSchedGetPriorityMax");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 146
	
	fn glass_call147_sched_get_priority_min(policy: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x93, // NR for sched_get_priority_min (147 in hex)
				policy as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call147GlassSchedGetPriorityMin");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 147
	
	fn glass_call148_sched_rr_get_interval(pid: pid_t, interval: *mut c_void) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0x94, // NR for sched_rr_get_interval (148 in hex)
				pid as u64,
				interval as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call148GlassSchedRrGetInterval");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 148
	
	fn glass_call149_mlock(start: c_ulong, len: size_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0x95, // NR for mlock (149 in hex)
				start as u64,
				len as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call149GlassMlock");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 149
	
	fn glass_call150_munlock(start: c_ulong, len: size_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0x96, // NR for munlock (150 in hex)
				start as u64,
				len as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call150GlassMunlock");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 150
	
	fn glass_call151_mlockall(flags: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x97, // NR for mlockall (151 in hex)
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call151GlassMlockall");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 151
	
	fn glass_call152_munlockall() -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x98, // NR for munlockall (152 in hex)
				0, // No arguments
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call152GlassMunlockall");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 152
	
	fn glass_call153_vhangup() -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x99, // NR for vhangup (153 in hex)
				0, // No arguments
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call153GlassVhangup");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 153
	
	// NR 154 - modify_ldt - marked as ? in table, will stub
	fn glass_call154_modify_ldt() -> Observation<i64> {
		// TODO: modify_ldt implementation - arguments marked as ? in syscall table
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call154GlassModifyLdt");
		Observation::unknown(segment).with_note("modify_ldt syscall not yet implemented - arguments unclear in table")
	} // NR 154
	
	fn glass_call155_pivot_root(new_root: &str, put_old: &str) -> Observation<i64> {
		// Create null-terminated C-style strings
		let mut new_root_bytes = alloc::vec![0u8; new_root.len() + 1];
		new_root_bytes[..new_root.len()].copy_from_slice(new_root.as_bytes());
		let mut put_old_bytes = alloc::vec![0u8; put_old.len() + 1];
		put_old_bytes[..put_old.len()].copy_from_slice(put_old.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall2(
				0x9B, // NR for pivot_root (155 in hex)
				new_root_bytes.as_ptr() as u64,
				put_old_bytes.as_ptr() as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call155GlassPivotRoot");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 155
	
	// NR 156 - _sysctl - marked as ? in table, will stub
	fn glass_call156_sysctl() -> Observation<i64> {
		// TODO: _sysctl implementation - arguments marked as ? in syscall table
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call156GlassSysctl");
		Observation::unknown(segment).with_note("_sysctl syscall not yet implemented - arguments unclear in table")
	} // NR 156
	
	fn glass_call157_prctl(option: i32, arg2: c_ulong, arg3: c_ulong, arg4: c_ulong, arg5: c_ulong) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall5(
				0x9D, // NR for prctl (157 in hex)
				option as u64,
				arg2 as u64,
				arg3 as u64,
				arg4 as u64,
				arg5 as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call157GlassPrctl");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 157
	
	// NR 158 - arch_prctl - marked as ? in table, will stub
	fn glass_call158_arch_prctl() -> Observation<i64> {
		// TODO: arch_prctl implementation - arguments marked as ? in syscall table
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call158GlassArchPrctl");
		Observation::unknown(segment).with_note("arch_prctl syscall not yet implemented - arguments unclear in table")
	} // NR 158
	
	fn glass_call159_adjtimex(txc_p: *mut c_void) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x9F, // NR for adjtimex (159 in hex)
				txc_p as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call159GlassAdjtimex");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 159
	
	fn glass_call160_setrlimit(resource: c_uint, rlim: *mut c_void) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0xA0, // NR for setrlimit (160 in hex)
				resource as u64,
				rlim as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call160GlassSetrlimit");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 160
	
	fn glass_call161_chroot(filename: &str) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut filename_bytes = alloc::vec![0u8; filename.len() + 1];
		filename_bytes[..filename.len()].copy_from_slice(filename.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall1(
				0xA1, // NR for chroot (161 in hex)
				filename_bytes.as_ptr() as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call161GlassChroot");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 161
	
	fn glass_call162_sync() -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0xA2, // NR for sync (162 in hex)
				0, // No arguments
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call162GlassSync");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 162
	
	fn glass_call163_acct(name: &str) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut name_bytes = alloc::vec![0u8; name.len() + 1];
		name_bytes[..name.len()].copy_from_slice(name.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall1(
				0xA3, // NR for acct (163 in hex)
				name_bytes.as_ptr() as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call163GlassAcct");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 163
	
	fn glass_call164_settimeofday(tv: *mut c_void, tz: *mut c_void) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0xA4, // NR for settimeofday (164 in hex)
				tv as u64,
				tz as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call164GlassSettimeofday");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 164
	
	fn glass_call165_mount(dev_name: &str, dir_name: &str, type_: &str, flags: c_ulong, data: *mut c_void) -> Observation<i64> {
		// Create null-terminated C-style strings
		let mut dev_name_bytes = alloc::vec![0u8; dev_name.len() + 1];
		dev_name_bytes[..dev_name.len()].copy_from_slice(dev_name.as_bytes());
		let mut dir_name_bytes = alloc::vec![0u8; dir_name.len() + 1];
		dir_name_bytes[..dir_name.len()].copy_from_slice(dir_name.as_bytes());
		let mut type_bytes = alloc::vec![0u8; type_.len() + 1];
		type_bytes[..type_.len()].copy_from_slice(type_.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall5(
				0xA5, // NR for mount (165 in hex)
				dev_name_bytes.as_ptr() as u64,
				dir_name_bytes.as_ptr() as u64,
				type_bytes.as_ptr() as u64,
				flags as u64,
				data as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call165GlassMount");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 165
	
	// NR 166 - umount2 - marked as ? in table, will stub
	fn glass_call166_umount2() -> Observation<i64> {
		// TODO: umount2 implementation - arguments marked as ? in syscall table
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call166GlassUmount2");
		Observation::unknown(segment).with_note("umount2 syscall not yet implemented - arguments unclear in table")
	} // NR 166
	
	fn glass_call167_swapon(specialfile: &str, swap_flags: i32) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut specialfile_bytes = alloc::vec![0u8; specialfile.len() + 1];
		specialfile_bytes[..specialfile.len()].copy_from_slice(specialfile.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall2(
				0xA7, // NR for swapon (167 in hex)
				specialfile_bytes.as_ptr() as u64,
				swap_flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call167GlassSwapon");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 167
	
	fn glass_call168_swapoff(specialfile: &str) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut specialfile_bytes = alloc::vec![0u8; specialfile.len() + 1];
		specialfile_bytes[..specialfile.len()].copy_from_slice(specialfile.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall1(
				0xA8, // NR for swapoff (168 in hex)
				specialfile_bytes.as_ptr() as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call168GlassSwapoff");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 168
	
	fn glass_call169_reboot(magic1: i32, magic2: i32, cmd: c_uint, arg: *mut c_void) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall4(
				0xA9, // NR for reboot (169 in hex)
				magic1 as u64,
				magic2 as u64,
				cmd as u64,
				arg as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call169GlassReboot");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 169
	
	fn glass_call170_sethostname(name: &str, len: i32) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut name_bytes = alloc::vec![0u8; name.len() + 1];
		name_bytes[..name.len()].copy_from_slice(name.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall2(
				0xAA, // NR for sethostname (170 in hex)
				name_bytes.as_ptr() as u64,
				len as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call170GlassSethostname");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 170
	
	fn glass_call171_setdomainname(name: &str, len: i32) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut name_bytes = alloc::vec![0u8; name.len() + 1];
		name_bytes[..name.len()].copy_from_slice(name.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall2(
				0xAB, // NR for setdomainname (171 in hex)
				name_bytes.as_ptr() as u64,
				len as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call171GlassSetdomainname");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 171
	
	// NR 172 - iopl - marked as ? in table, will stub
	fn glass_call172_iopl() -> Observation<i64> {
		// TODO: iopl implementation - arguments marked as ? in syscall table
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call172GlassIopl");
		Observation::unknown(segment).with_note("iopl syscall not yet implemented - arguments unclear in table")
	} // NR 172
	
	fn glass_call173_ioperm(from: c_ulong, num: c_ulong, on: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0xAD, // NR for ioperm (173 in hex)
				from as u64,
				num as u64,
				on as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call173GlassIoperm");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 173
	
	// NR 174 - create_module - marked as ? in table, will stub
	fn glass_call174_create_module() -> Observation<i64> {
		// TODO: create_module implementation - arguments marked as ? in syscall table
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call174GlassCreateModule");
		Observation::unknown(segment).with_note("create_module syscall not yet implemented - arguments unclear in table")
	} // NR 174
	
	fn glass_call175_init_module(umod: *mut c_void, len: c_ulong, uargs: &str) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut uargs_bytes = alloc::vec![0u8; uargs.len() + 1];
		uargs_bytes[..uargs.len()].copy_from_slice(uargs.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall3(
				0xAF, // NR for init_module (175 in hex)
				umod as u64,
				len as u64,
				uargs_bytes.as_ptr() as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call175GlassInitModule");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 175
	
	fn glass_call176_delete_module(name_user: &str, flags: c_uint) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut name_user_bytes = alloc::vec![0u8; name_user.len() + 1];
		name_user_bytes[..name_user.len()].copy_from_slice(name_user.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall2(
				0xB0, // NR for delete_module (176 in hex)
				name_user_bytes.as_ptr() as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call176GlassDeleteModule");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 176
	
	// NR 177-178 - get_kernel_syms, query_module - marked as ? in table, will stub
	fn glass_call177_get_kernel_syms() -> Observation<i64> {
		// TODO: get_kernel_syms implementation - arguments marked as ? in syscall table
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call177GlassGetKernelSyms");
		Observation::unknown(segment).with_note("get_kernel_syms syscall not yet implemented - arguments unclear in table")
	} // NR 177
	
	fn glass_call178_query_module() -> Observation<i64> {
		// TODO: query_module implementation - arguments marked as ? in syscall table
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call178GlassQueryModule");
		Observation::unknown(segment).with_note("query_module syscall not yet implemented - arguments unclear in table")
	} // NR 178
	
	fn glass_call179_quotactl(cmd: c_uint, special: &str, id: qid_t, addr: *mut c_void) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut special_bytes = alloc::vec![0u8; special.len() + 1];
		special_bytes[..special.len()].copy_from_slice(special.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall4(
				0xB3, // NR for quotactl (179 in hex)
				cmd as u64,
				special_bytes.as_ptr() as u64,
				id as u64,
				addr as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call179GlassQuotactl");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 179
	
	// NR 180-185 - Various syscalls marked as ? in table, will stub
	fn glass_call180_nfsservctl() -> Observation<i64> {
		// TODO: nfsservctl implementation - arguments marked as ? in syscall table
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call180GlassNfsservctl");
		Observation::unknown(segment).with_note("nfsservctl syscall not yet implemented - arguments unclear in table")
	} // NR 180
	
	fn glass_call181_getpmsg() -> Observation<i64> {
		// TODO: getpmsg implementation - arguments marked as ? in syscall table
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call181GlassGetpmsg");
		Observation::unknown(segment).with_note("getpmsg syscall not yet implemented - arguments unclear in table")
	} // NR 181
	
	fn glass_call182_putpmsg() -> Observation<i64> {
		// TODO: putpmsg implementation - arguments marked as ? in syscall table
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call182GlassPutpmsg");
		Observation::unknown(segment).with_note("putpmsg syscall not yet implemented - arguments unclear in table")
	} // NR 182
	
	fn glass_call183_afs_syscall() -> Observation<i64> {
		// TODO: afs_syscall implementation - arguments marked as ? in syscall table
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call183GlassAfsSyscall");
		Observation::unknown(segment).with_note("afs_syscall syscall not yet implemented - arguments unclear in table")
	} // NR 183
	
	fn glass_call184_tuxcall() -> Observation<i64> {
		// TODO: tuxcall implementation - arguments marked as ? in syscall table
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call184GlassTuxcall");
		Observation::unknown(segment).with_note("tuxcall syscall not yet implemented - arguments unclear in table")
	} // NR 184
	
	fn glass_call185_security() -> Observation<i64> {
		// TODO: security implementation - arguments marked as ? in syscall table
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call185GlassSecurity");
		Observation::unknown(segment).with_note("security syscall not yet implemented - arguments unclear in table")
	} // NR 185
	
	fn glass_call186_gettid() -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0xBA, // NR for gettid (186 in hex)
				0, // No arguments
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call186GlassGettid");
		// gettid() never fails
		Observation::stable(result, segment)
	} // NR 186
	
	fn glass_call187_readahead(fd: i32, offset: loff_t, count: size_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0xBB, // NR for readahead (187 in hex)
				fd as u64,
				offset as u64,
				count as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call187GlassReadahead");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 187
	
	fn glass_call188_setxattr(path: &str, name: &str, value: *const c_void, size: size_t, flags: i32) -> Observation<i64> {
		// Create null-terminated C-style strings
		let mut path_bytes = alloc::vec![0u8; path.len() + 1];
		path_bytes[..path.len()].copy_from_slice(path.as_bytes());
		let mut name_bytes = alloc::vec![0u8; name.len() + 1];
		name_bytes[..name.len()].copy_from_slice(name.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall5(
				0xBC, // NR for setxattr (188 in hex)
				path_bytes.as_ptr() as u64,
				name_bytes.as_ptr() as u64,
				value as u64,
				size as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call188GlassSetxattr");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 188
	
	fn glass_call189_lsetxattr(path: &str, name: &str, value: *const c_void, size: size_t, flags: i32) -> Observation<i64> {
		// Create null-terminated C-style strings
		let mut path_bytes = alloc::vec![0u8; path.len() + 1];
		path_bytes[..path.len()].copy_from_slice(path.as_bytes());
		let mut name_bytes = alloc::vec![0u8; name.len() + 1];
		name_bytes[..name.len()].copy_from_slice(name.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall5(
				0xBD, // NR for lsetxattr (189 in hex)
				path_bytes.as_ptr() as u64,
				name_bytes.as_ptr() as u64,
				value as u64,
				size as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call189GlassLsetxattr");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 189
	
	fn glass_call190_fsetxattr(fd: i32, name: &str, value: *const c_void, size: size_t, flags: i32) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut name_bytes = alloc::vec![0u8; name.len() + 1];
		name_bytes[..name.len()].copy_from_slice(name.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall5(
				0xBE, // NR for fsetxattr (190 in hex)
				fd as u64,
				name_bytes.as_ptr() as u64,
				value as u64,
				size as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call190GlassFsetxattr");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 190
	
	fn glass_call191_getxattr(path: &str, name: &str, value: *mut c_void, size: size_t) -> Observation<i64> {
		// Create null-terminated C-style strings
		let mut path_bytes = alloc::vec![0u8; path.len() + 1];
		path_bytes[..path.len()].copy_from_slice(path.as_bytes());
		let mut name_bytes = alloc::vec![0u8; name.len() + 1];
		name_bytes[..name.len()].copy_from_slice(name.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall4(
				0xBF, // NR for getxattr (191 in hex)
				path_bytes.as_ptr() as u64,
				name_bytes.as_ptr() as u64,
				value as u64,
				size as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call191GlassGetxattr");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 191
	
	fn glass_call192_lgetxattr(path: &str, name: &str, value: *mut c_void, size: size_t) -> Observation<i64> {
		// Create null-terminated C-style strings
		let mut path_bytes = alloc::vec![0u8; path.len() + 1];
		path_bytes[..path.len()].copy_from_slice(path.as_bytes());
		let mut name_bytes = alloc::vec![0u8; name.len() + 1];
		name_bytes[..name.len()].copy_from_slice(name.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall4(
				0xC0, // NR for lgetxattr (192 in hex)
				path_bytes.as_ptr() as u64,
				name_bytes.as_ptr() as u64,
				value as u64,
				size as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call192GlassLgetxattr");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 192
	
	fn glass_call193_fgetxattr(fd: i32, name: &str, value: *mut c_void, size: size_t) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut name_bytes = alloc::vec![0u8; name.len() + 1];
		name_bytes[..name.len()].copy_from_slice(name.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall4(
				0xC1, // NR for fgetxattr (193 in hex)
				fd as u64,
				name_bytes.as_ptr() as u64,
				value as u64,
				size as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call193GlassFgetxattr");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 193
	
	fn glass_call194_listxattr(path: &str, list: *mut c_char, size: size_t) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut path_bytes = alloc::vec![0u8; path.len() + 1];
		path_bytes[..path.len()].copy_from_slice(path.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall3(
				0xC2, // NR for listxattr (194 in hex)
				path_bytes.as_ptr() as u64,
				list as u64,
				size as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call194GlassListxattr");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 194
	
	fn glass_call195_llistxattr(path: &str, list: *mut c_char, size: size_t) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut path_bytes = alloc::vec![0u8; path.len() + 1];
		path_bytes[..path.len()].copy_from_slice(path.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall3(
				0xC3, // NR for llistxattr (195 in hex)
				path_bytes.as_ptr() as u64,
				list as u64,
				size as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call195GlassLlistxattr");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 195
	
	fn glass_call196_flistxattr(fd: i32, list: *mut c_char, size: size_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0xC4, // NR for flistxattr (196 in hex)
				fd as u64,
				list as u64,
				size as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call196GlassFlistxattr");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 196
	
	fn glass_call197_removexattr(path: &str, name: &str) -> Observation<i64> {
		// Create null-terminated C-style strings
		let mut path_bytes = alloc::vec![0u8; path.len() + 1];
		path_bytes[..path.len()].copy_from_slice(path.as_bytes());
		let mut name_bytes = alloc::vec![0u8; name.len() + 1];
		name_bytes[..name.len()].copy_from_slice(name.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall2(
				0xC5, // NR for removexattr (197 in hex)
				path_bytes.as_ptr() as u64,
				name_bytes.as_ptr() as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call197GlassRemovexattr");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 197
	
	fn glass_call198_lremovexattr(path: &str, name: &str) -> Observation<i64> {
		// Create null-terminated C-style strings
		let mut path_bytes = alloc::vec![0u8; path.len() + 1];
		path_bytes[..path.len()].copy_from_slice(path.as_bytes());
		let mut name_bytes = alloc::vec![0u8; name.len() + 1];
		name_bytes[..name.len()].copy_from_slice(name.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall2(
				0xC6, // NR for lremovexattr (198 in hex)
				path_bytes.as_ptr() as u64,
				name_bytes.as_ptr() as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call198GlassLremovexattr");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 198
	
	fn glass_call199_fremovexattr(fd: i32, name: &str) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut name_bytes = alloc::vec![0u8; name.len() + 1];
		name_bytes[..name.len()].copy_from_slice(name.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall2(
				0xC7, // NR for fremovexattr (199 in hex)
				fd as u64,
				name_bytes.as_ptr() as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call199GlassFremovexattr");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 199
	
	fn glass_call200_tkill(pid: pid_t, sig: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0xC8, // NR for tkill (200 in hex)
				pid as u64,
				sig as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call200GlassTkill");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 200
	
	fn glass_call201_time(tloc: *mut time_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0xC9, // NR for time (201 in hex)
				tloc as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call201GlassTime");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 201
	
	fn glass_call202_futex(uaddr: *mut u32, op: i32, val: u32, utime: *const __kernel_timespec, uaddr2: *mut u32, val3: u32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall6(
				0xCA, // NR for futex (202 in hex)
				uaddr as u64,
				op as u64,
				val as u64,
				utime as u64,
				uaddr2 as u64,
				val3 as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call202GlassFutex");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 202
	
	fn glass_call203_sched_setaffinity(pid: pid_t, len: c_uint, user_mask_ptr: *const c_ulong) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0xCB, // NR for sched_setaffinity (203 in hex)
				pid as u64,
				len as u64,
				user_mask_ptr as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call203GlassSchedSetaffinity");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 203
	
	fn glass_call204_sched_getaffinity(pid: pid_t, len: c_uint, user_mask_ptr: *mut c_ulong) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0xCC, // NR for sched_getaffinity (204 in hex)
				pid as u64,
				len as u64,
				user_mask_ptr as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call204GlassSchedGetaffinity");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 204
	
	fn glass_call205_set_thread_area() -> Observation<i64> {
		// TODO: Parameters unknown - marked with ? in table
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call205GlassSetThreadArea");
		Observation::unknown(segment).with_note("set_thread_area syscall not implemented - parameters unknown")
	} // NR 205
	
	fn glass_call206_io_setup(nr_reqs: c_uint, ctx: *mut aio_context_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0xCE, // NR for io_setup (206 in hex)
				nr_reqs as u64,
				ctx as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call206GlassIoSetup");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 206
	
	fn glass_call207_io_destroy(ctx: aio_context_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0xCF, // NR for io_destroy (207 in hex)
				ctx as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call207GlassIoDestroy");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 207
	
	fn glass_call208_io_getevents(ctx_id: aio_context_t, min_nr: c_long, nr: c_long, events: *mut io_event, timeout: *const __kernel_timespec) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall5(
				0xD0, // NR for io_getevents (208 in hex)
				ctx_id as u64,
				min_nr as u64,
				nr as u64,
				events as u64,
				timeout as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call208GlassIoGetevents");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 208
	
	fn glass_call209_io_submit(ctx: aio_context_t, nr: c_long, iocbpp: *const *const iocb) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0xD1, // NR for io_submit (209 in hex)
				ctx as u64,
				nr as u64,
				iocbpp as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call209GlassIoSubmit");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 209
	
	fn glass_call210_io_cancel(ctx_id: aio_context_t, iocb: *const iocb, result: *mut io_event) -> Observation<i64> {
		let result_val = unsafe {
			Self::raw_syscall3(
				0xD2, // NR for io_cancel (210 in hex)
				ctx_id as u64,
				iocb as u64,
				result as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call210GlassIoCancel");
		if result_val < 0 {
			Self::escalate(result_val as i32)
		} else {
			Observation::stable(result_val, segment)
		}
	} // NR 210
	
	fn glass_call211_get_thread_area() -> Observation<i64> {
		// TODO: Parameters unknown - marked with ? in table
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call211GlassGetThreadArea");
		Observation::unknown(segment).with_note("get_thread_area syscall not implemented - parameters unknown")
	} // NR 211
	
	fn glass_call212_lookup_dcookie(cookie64: u64, buf: *mut c_char, len: size_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0xD4, // NR for lookup_dcookie (212 in hex)
				cookie64 as u64,
				buf as u64,
				len as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call212GlassLookupDcookie");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 212
	
	fn glass_call213_epoll_create(size: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0xD5, // NR for epoll_create (213 in hex)
				size as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call213GlassEpollCreate");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 213
	
	fn glass_call214_epoll_ctl_old() -> Observation<i64> {
		// TODO: Parameters unknown - marked with ? in table
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call214GlassEpollCtlOld");
		Observation::unknown(segment).with_note("epoll_ctl_old syscall not implemented - parameters unknown")
	} // NR 214
	
	fn glass_call215_epoll_wait_old() -> Observation<i64> {
		// TODO: Parameters unknown - marked with ? in table
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call215GlassEpollWaitOld");
		Observation::unknown(segment).with_note("epoll_wait_old syscall not implemented - parameters unknown")
	} // NR 215
	
	fn glass_call216_remap_file_pages(start: c_ulong, size: c_ulong, prot: c_ulong, pgoff: c_ulong, flags: c_ulong) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall5(
				0xD8, // NR for remap_file_pages (216 in hex)
				start as u64,
				size as u64,
				prot as u64,
				pgoff as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call216GlassRemapFilePages");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 216
	
	fn glass_call217_getdents64(fd: c_uint, dirent: *mut linux_dirent64, count: c_uint) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0xD9, // NR for getdents64 (217 in hex)
				fd as u64,
				dirent as u64,
				count as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call217GlassGetdents64");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 217
	
	fn glass_call218_set_tid_address(tidptr: *mut i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0xDA, // NR for set_tid_address (218 in hex)
				tidptr as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call218GlassSetTidAddress");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 218
	
	fn glass_call219_restart_syscall() -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0xDB, // NR for restart_syscall (219 in hex)
				0, // No parameters
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call219GlassRestartSyscall");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 219
	
	fn glass_call220_semtimedop(semid: i32, sops: *mut sembuf, nsops: c_uint, timeout: *const __kernel_timespec) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall4(
				0xDC, // NR for semtimedop (220 in hex)
				semid as u64,
				sops as u64,
				nsops as u64,
				timeout as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call220GlassSemtimedop");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 220
	
	fn glass_call221_fadvise64(fd: i32, offset: loff_t, len: size_t, advice: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall4(
				0xDD, // NR for fadvise64 (221 in hex)
				fd as u64,
				offset as u64,
				len as u64,
				advice as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call221GlassFadvise64");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 221
	
	fn glass_call222_timer_create(which_clock: clockid_t, timer_event_spec: *mut sigevent, created_timer_id: *mut timer_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0xDE, // NR for timer_create (222 in hex)
				which_clock as u64,
				timer_event_spec as u64,
				created_timer_id as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call222GlassTimerCreate");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 222
	
	fn glass_call223_timer_settime(timer_id: timer_t, flags: i32, new_setting: *const __kernel_itimerspec, old_setting: *mut __kernel_itimerspec) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall4(
				0xDF, // NR for timer_settime (223 in hex)
				timer_id as u64,
				flags as u64,
				new_setting as u64,
				old_setting as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call223GlassTimerSettime");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 223
	
	fn glass_call224_timer_gettime(timer_id: timer_t, setting: *mut __kernel_itimerspec) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0xE0, // NR for timer_gettime (224 in hex)
				timer_id as u64,
				setting as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call224GlassTimerGettime");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 224
	
	fn glass_call225_timer_getoverrun(timer_id: timer_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0xE1, // NR for timer_getoverrun (225 in hex)
				timer_id as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call225GlassTimerGetoverrun");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 225
	
	fn glass_call226_timer_delete(timer_id: timer_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0xE2, // NR for timer_delete (226 in hex)
				timer_id as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call226GlassTimerDelete");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 226
	
	fn glass_call227_clock_settime(which_clock: clockid_t, tp: *const __kernel_timespec) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0xE3, // NR for clock_settime (227 in hex)
				which_clock as u64,
				tp as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call227GlassClockSettime");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 227
	
	fn glass_call228_clock_gettime(which_clock: clockid_t, tp: *mut __kernel_timespec) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0xE4, // NR for clock_gettime (228 in hex)
				which_clock as u64,
				tp as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call228GlassClockGettime");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 228
	
	fn glass_call229_clock_getres(which_clock: clockid_t, tp: *mut __kernel_timespec) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0xE5, // NR for clock_getres (229 in hex)
				which_clock as u64,
				tp as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call229GlassClockGetres");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 229
	
	fn glass_call230_clock_nanosleep(which_clock: clockid_t, flags: i32, rqtp: *const __kernel_timespec, rmtp: *mut __kernel_timespec) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall4(
				0xE6, // NR for clock_nanosleep (230 in hex)
				which_clock as u64,
				flags as u64,
				rqtp as u64,
				rmtp as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call230GlassClockNanosleep");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 230
	
	fn glass_call231_exit_group(error_code: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0xE7, // NR for exit_group (231 in hex)
				error_code as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call231GlassExitGroup");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 231
	
	fn glass_call232_epoll_wait(epfd: i32, events: *mut epoll_event, maxevents: i32, timeout: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall4(
				0xE8, // NR for epoll_wait (232 in hex)
				epfd as u64,
				events as u64,
				maxevents as u64,
				timeout as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call232GlassEpollWait");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 232
	
	fn glass_call233_epoll_ctl(epfd: i32, op: i32, fd: i32, event: *mut epoll_event) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall4(
				0xE9, // NR for epoll_ctl (233 in hex)
				epfd as u64,
				op as u64,
				fd as u64,
				event as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call233GlassEpollCtl");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 233
	
	fn glass_call234_tgkill(tgid: pid_t, pid: pid_t, sig: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0xEA, // NR for tgkill (234 in hex)
				tgid as u64,
				pid as u64,
				sig as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call234GlassTgkill");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 234
	
	fn glass_call235_utimes(filename: &str, utimes: *mut timeval) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut filename_bytes = alloc::vec![0u8; filename.len() + 1];
		filename_bytes[..filename.len()].copy_from_slice(filename.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall2(
				0xEB, // NR for utimes (235 in hex)
				filename_bytes.as_ptr() as u64,
				utimes as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call235GlassUtimes");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 235
	
	fn glass_call236_vserver() -> Observation<i64> {
		// TODO: Parameters unknown - marked with ? in table
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call236GlassVserver");
		Observation::unknown(segment).with_note("vserver syscall not implemented - parameters unknown")
	} // NR 236
	
	fn glass_call237_mbind(start: c_ulong, len: c_ulong, mode: c_ulong, nmask: *const c_ulong, maxnode: c_ulong, flags: c_uint) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall6(
				0xED, // NR for mbind (237 in hex)
				start as u64,
				len as u64,
				mode as u64,
				nmask as u64,
				maxnode as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call237GlassMbind");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 237
	
	fn glass_call238_set_mempolicy(mode: i32, nmask: *const c_ulong, maxnode: c_ulong) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0xEE, // NR for set_mempolicy (238 in hex)
				mode as u64,
				nmask as u64,
				maxnode as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call238GlassSetMempolicy");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 238
	
	fn glass_call239_get_mempolicy(policy: *mut i32, nmask: *mut c_ulong, maxnode: c_ulong, addr: c_ulong, flags: c_ulong) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall5(
				0xEF, // NR for get_mempolicy (239 in hex)
				policy as u64,
				nmask as u64,
				maxnode as u64,
				addr as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call239GlassGetMempolicy");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 239
	
	fn glass_call240_mq_open(name: &str, oflag: i32, mode: umode_t, attr: *mut mq_attr) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut name_bytes = alloc::vec![0u8; name.len() + 1];
		name_bytes[..name.len()].copy_from_slice(name.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall4(
				0xF0, // NR for mq_open (240 in hex)
				name_bytes.as_ptr() as u64,
				oflag as u64,
				mode as u64,
				attr as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call240GlassMqOpen");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 240
	
	fn glass_call241_mq_unlink(name: &str) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut name_bytes = alloc::vec![0u8; name.len() + 1];
		name_bytes[..name.len()].copy_from_slice(name.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall1(
				0xF1, // NR for mq_unlink (241 in hex)
				name_bytes.as_ptr() as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call241GlassMqUnlink");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 241
	
	fn glass_call242_mq_timedsend(mqdes: mqd_t, msg_ptr: *const c_char, msg_len: size_t, msg_prio: c_uint, abs_timeout: *const __kernel_timespec) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall5(
				0xF2, // NR for mq_timedsend (242 in hex)
				mqdes as u64,
				msg_ptr as u64,
				msg_len as u64,
				msg_prio as u64,
				abs_timeout as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call242GlassMqTimedsend");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 242
	
	fn glass_call243_mq_timedreceive(mqdes: mqd_t, msg_ptr: *mut c_char, msg_len: size_t, msg_prio: *mut c_uint, abs_timeout: *const __kernel_timespec) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall5(
				0xF3, // NR for mq_timedreceive (243 in hex)
				mqdes as u64,
				msg_ptr as u64,
				msg_len as u64,
				msg_prio as u64,
				abs_timeout as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call243GlassMqTimedreceive");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 243
	
	fn glass_call244_mq_notify(mqdes: mqd_t, notification: *const sigevent) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0xF4, // NR for mq_notify (244 in hex)
				mqdes as u64,
				notification as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call244GlassMqNotify");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 244
	
	fn glass_call245_mq_getsetattr(mqdes: mqd_t, mqstat: *const mq_attr, omqstat: *mut mq_attr) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0xF5, // NR for mq_getsetattr (245 in hex)
				mqdes as u64,
				mqstat as u64,
				omqstat as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call245GlassMqGetsetattr");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 245
	
	fn glass_call246_kexec_load(entry: c_ulong, nr_segments: c_ulong, segments: *mut kexec_segment, flags: c_ulong) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall4(
				0xF6, // NR for kexec_load (246 in hex)
				entry as u64,
				nr_segments as u64,
				segments as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call246GlassKexecLoad");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 246
	
	fn glass_call247_waitid(which: i32, pid: pid_t, infop: *mut siginfo_t, options: i32, ru: *mut rusage) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall5(
				0xF7, // NR for waitid (247 in hex)
				which as u64,
				pid as u64,
				infop as u64,
				options as u64,
				ru as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call247GlassWaitid");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 247
	
	fn glass_call248_add_key(_type: &str, _description: &str, _payload: *const c_void, plen: size_t, destringid: key_serial_t) -> Observation<i64> {
		// Create null-terminated C-style strings
		let mut type_bytes = alloc::vec![0u8; _type.len() + 1];
		type_bytes[.._type.len()].copy_from_slice(_type.as_bytes());
		let mut desc_bytes = alloc::vec![0u8; _description.len() + 1];
		desc_bytes[.._description.len()].copy_from_slice(_description.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall5(
				0xF8, // NR for add_key (248 in hex)
				type_bytes.as_ptr() as u64,
				desc_bytes.as_ptr() as u64,
				_payload as u64,
				plen as u64,
				destringid as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call248GlassAddKey");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 248
	
	fn glass_call249_request_key(_type: &str, _description: &str, _callout_info: &str, destringid: key_serial_t) -> Observation<i64> {
		// Create null-terminated C-style strings
		let mut type_bytes = alloc::vec![0u8; _type.len() + 1];
		type_bytes[.._type.len()].copy_from_slice(_type.as_bytes());
		let mut desc_bytes = alloc::vec![0u8; _description.len() + 1];
		desc_bytes[.._description.len()].copy_from_slice(_description.as_bytes());
		let mut callout_bytes = alloc::vec![0u8; _callout_info.len() + 1];
		callout_bytes[.._callout_info.len()].copy_from_slice(_callout_info.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall4(
				0xF9, // NR for request_key (249 in hex)
				type_bytes.as_ptr() as u64,
				desc_bytes.as_ptr() as u64,
				callout_bytes.as_ptr() as u64,
				destringid as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call249GlassRequestKey");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 249
	
	fn glass_call250_keyctl(cmd: i32, arg2: c_ulong, arg3: c_ulong, arg4: c_ulong, arg5: c_ulong) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall5(
				0xFA, // NR for keyctl (250 in hex)
				cmd as u64,
				arg2 as u64,
				arg3 as u64,
				arg4 as u64,
				arg5 as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call250GlassKeyctl");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 250
	
	fn glass_call251_ioprio_set(which: i32, who: i32, ioprio: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0xFB, // NR for ioprio_set (251 in hex)
				which as u64,
				who as u64,
				ioprio as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call251GlassIoprioSet");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 251
	
	fn glass_call252_ioprio_get(which: i32, who: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0xFC, // NR for ioprio_get (252 in hex)
				which as u64,
				who as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call252GlassIoprioGet");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 252
	
	fn glass_call253_inotify_init() -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0xFD, // NR for inotify_init (253 in hex)
				0, // No parameters
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call253GlassInotifyInit");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 253
	
	fn glass_call254_inotify_add_watch(fd: i32, path: &str, mask: u32) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut path_bytes = alloc::vec![0u8; path.len() + 1];
		path_bytes[..path.len()].copy_from_slice(path.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall3(
				0xFE, // NR for inotify_add_watch (254 in hex)
				fd as u64,
				path_bytes.as_ptr() as u64,
				mask as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call254GlassInotifyAddWatch");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 254
	
	fn glass_call255_inotify_rm_watch(fd: i32, wd: __s32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0xFF, // NR for inotify_rm_watch (255 in hex)
				fd as u64,
				wd as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call255GlassInotifyRmWatch");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 255
	
	fn glass_call256_migrate_pages(pid: pid_t, maxnode: c_ulong, from: *const c_ulong, to: *const c_ulong) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall4(
				0x100, // NR for migrate_pages (256 in hex)
				pid as u64,
				maxnode as u64,
				from as u64,
				to as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call256GlassMigratePages");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 256
	
	fn glass_call257_openat(dfd: i32, filename: &str, flags: i32, mode: umode_t) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut filename_bytes = alloc::vec![0u8; filename.len() + 1];
		filename_bytes[..filename.len()].copy_from_slice(filename.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall4(
				0x101, // NR for openat (257 in hex)
				dfd as u64,
				filename_bytes.as_ptr() as u64,
				flags as u64,
				mode as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call257GlassOpenat");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 257
	
	fn glass_call258_mkdirat(dfd: i32, pathname: &str, mode: umode_t) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut pathname_bytes = alloc::vec![0u8; pathname.len() + 1];
		pathname_bytes[..pathname.len()].copy_from_slice(pathname.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall3(
				0x102, // NR for mkdirat (258 in hex)
				dfd as u64,
				pathname_bytes.as_ptr() as u64,
				mode as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call258GlassMkdirat");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 258
	
	fn glass_call259_mknodat(dfd: i32, filename: &str, mode: umode_t, dev: c_uint) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut filename_bytes = alloc::vec![0u8; filename.len() + 1];
		filename_bytes[..filename.len()].copy_from_slice(filename.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall4(
				0x103, // NR for mknodat (259 in hex)
				dfd as u64,
				filename_bytes.as_ptr() as u64,
				mode as u64,
				dev as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call259GlassMknodat");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 259
	
	fn glass_call260_fchownat(dfd: i32, filename: &str, user: uid_t, group: gid_t, flag: i32) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut filename_bytes = alloc::vec![0u8; filename.len() + 1];
		filename_bytes[..filename.len()].copy_from_slice(filename.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall5(
				0x104, // NR for fchownat (260 in hex)
				dfd as u64,
				filename_bytes.as_ptr() as u64,
				user as u64,
				group as u64,
				flag as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call260GlassFchownat");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 260
	
	fn glass_call261_futimesat(dfd: i32, filename: &str, utimes: *mut timeval) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut filename_bytes = alloc::vec![0u8; filename.len() + 1];
		filename_bytes[..filename.len()].copy_from_slice(filename.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall3(
				0x105, // NR for futimesat (261 in hex)
				dfd as u64,
				filename_bytes.as_ptr() as u64,
				utimes as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call261GlassFutimesat");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 261
	
	fn glass_call262_newfstatat(dfd: i32, filename: &str, statbuf: *mut stat, flag: i32) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut filename_bytes = alloc::vec![0u8; filename.len() + 1];
		filename_bytes[..filename.len()].copy_from_slice(filename.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall4(
				0x106, // NR for newfstatat (262 in hex)
				dfd as u64,
				filename_bytes.as_ptr() as u64,
				statbuf as u64,
				flag as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call262GlassNewfstatat");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 262
	
	fn glass_call263_unlinkat(dfd: i32, pathname: &str, flag: i32) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut pathname_bytes = alloc::vec![0u8; pathname.len() + 1];
		pathname_bytes[..pathname.len()].copy_from_slice(pathname.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall3(
				0x107, // NR for unlinkat (263 in hex)
				dfd as u64,
				pathname_bytes.as_ptr() as u64,
				flag as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call263GlassUnlinkat");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 263
	
	fn glass_call264_renameat(olddfd: i32, oldname: &str, newdfd: i32, newname: &str) -> Observation<i64> {
		// Create null-terminated C-style strings
		let mut oldname_bytes = alloc::vec![0u8; oldname.len() + 1];
		oldname_bytes[..oldname.len()].copy_from_slice(oldname.as_bytes());
		let mut newname_bytes = alloc::vec![0u8; newname.len() + 1];
		newname_bytes[..newname.len()].copy_from_slice(newname.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall4(
				0x108, // NR for renameat (264 in hex)
				olddfd as u64,
				oldname_bytes.as_ptr() as u64,
				newdfd as u64,
				newname_bytes.as_ptr() as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call264GlassRenameat");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 264
	
	fn glass_call265_linkat(olddfd: i32, oldname: &str, newdfd: i32, newname: &str, flags: i32) -> Observation<i64> {
		// Create null-terminated C-style strings
		let mut oldname_bytes = alloc::vec![0u8; oldname.len() + 1];
		oldname_bytes[..oldname.len()].copy_from_slice(oldname.as_bytes());
		let mut newname_bytes = alloc::vec![0u8; newname.len() + 1];
		newname_bytes[..newname.len()].copy_from_slice(newname.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall5(
				0x109, // NR for linkat (265 in hex)
				olddfd as u64,
				oldname_bytes.as_ptr() as u64,
				newdfd as u64,
				newname_bytes.as_ptr() as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call265GlassLinkat");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 265
	
	fn glass_call266_symlinkat(oldname: &str, newdfd: i32, newname: &str) -> Observation<i64> {
		// Create null-terminated C-style strings
		let mut oldname_bytes = alloc::vec![0u8; oldname.len() + 1];
		oldname_bytes[..oldname.len()].copy_from_slice(oldname.as_bytes());
		let mut newname_bytes = alloc::vec![0u8; newname.len() + 1];
		newname_bytes[..newname.len()].copy_from_slice(newname.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall3(
				0x10A, // NR for symlinkat (266 in hex)
				oldname_bytes.as_ptr() as u64,
				newdfd as u64,
				newname_bytes.as_ptr() as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call266GlassSymlinkat");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 266
	
	fn glass_call267_readlinkat(dfd: i32, path: &str, buf: *mut c_char, bufsiz: i32) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut path_bytes = alloc::vec![0u8; path.len() + 1];
		path_bytes[..path.len()].copy_from_slice(path.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall4(
				0x10B, // NR for readlinkat (267 in hex)
				dfd as u64,
				path_bytes.as_ptr() as u64,
				buf as u64,
				bufsiz as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call267GlassReadlinkat");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 267
	
	fn glass_call268_fchmodat(dfd: i32, filename: &str, mode: umode_t) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut filename_bytes = alloc::vec![0u8; filename.len() + 1];
		filename_bytes[..filename.len()].copy_from_slice(filename.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall3(
				0x10C, // NR for fchmodat (268 in hex)
				dfd as u64,
				filename_bytes.as_ptr() as u64,
				mode as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call268GlassFchmodat");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 268
	
	fn glass_call269_faccessat(dfd: i32, filename: &str, mode: i32) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut filename_bytes = alloc::vec![0u8; filename.len() + 1];
		filename_bytes[..filename.len()].copy_from_slice(filename.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall3(
				0x10D, // NR for faccessat (269 in hex)
				dfd as u64,
				filename_bytes.as_ptr() as u64,
				mode as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call269GlassFaccessat");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 269
	
	fn glass_call270_pselect6(n: i32, inp: *mut fd_set, outp: *mut fd_set, exp: *mut fd_set, tsp: *mut __kernel_timespec, sig: *mut c_void) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall6(
				0x10E, // NR for pselect6 (270 in hex)
				n as u64,
				inp as u64,
				outp as u64,
				exp as u64,
				tsp as u64,
				sig as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call270GlassPselect6");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 270
	
	fn glass_call271_ppoll(fds: *mut pollfd, nfds: c_uint, tsp: *mut __kernel_timespec, sigmask: *const sigset_t, sigsetsize: size_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall5(
				0x10F, // NR for ppoll (271 in hex)
				fds as u64,
				nfds as u64,
				tsp as u64,
				sigmask as u64,
				sigsetsize as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call271GlassPpoll");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 271
	
	fn glass_call272_unshare(unshare_flags: c_ulong) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x110, // NR for unshare (272 in hex)
				unshare_flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call272GlassUnshare");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 272
	
	fn glass_call273_set_robust_list(head: *mut robust_list_head, len: size_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0x111, // NR for set_robust_list (273 in hex)
				head as u64,
				len as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call273GlassSetRobustList");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 273
	
	fn glass_call274_get_robust_list(pid: i32, head_ptr: *mut *mut robust_list_head, len_ptr: *mut size_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x112, // NR for get_robust_list (274 in hex)
				pid as u64,
				head_ptr as u64,
				len_ptr as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call274GlassGetRobustList");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 274
	
	fn glass_call275_splice(fd_in: i32, off_in: *mut loff_t, fd_out: i32, off_out: *mut loff_t, len: size_t, flags: c_uint) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall6(
				0x113, // NR for splice (275 in hex)
				fd_in as u64,
				off_in as u64,
				fd_out as u64,
				off_out as u64,
				len as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call275GlassSplice");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 275
	
	fn glass_call276_tee(fdin: i32, fdout: i32, len: size_t, flags: c_uint) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall4(
				0x114, // NR for tee (276 in hex)
				fdin as u64,
				fdout as u64,
				len as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call276GlassTee");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 276
	
	fn glass_call277_sync_file_range(fd: i32, offset: loff_t, nbytes: loff_t, flags: c_uint) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall4(
				0x115, // NR for sync_file_range (277 in hex)
				fd as u64,
				offset as u64,
				nbytes as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call277GlassSyncFileRange");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 277
	
	fn glass_call278_vmsplice(fd: i32, iov: *const iovec, nr_segs: c_ulong, flags: c_uint) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall4(
				0x116, // NR for vmsplice (278 in hex)
				fd as u64,
				iov as u64,
				nr_segs as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call278GlassVmsplice");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 278
	
	fn glass_call279_move_pages(pid: pid_t, nr_pages: c_ulong, pages: *const *const c_void, nodes: *const i32, status: *mut i32, flags: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall6(
				0x117, // NR for move_pages (279 in hex)
				pid as u64,
				nr_pages as u64,
				pages as u64,
				nodes as u64,
				status as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call279GlassMovePages");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 279
	
	fn glass_call280_utimensat(dfd: i32, filename: &str, utimes: *mut __kernel_timespec, flags: i32) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut filename_bytes = alloc::vec![0u8; filename.len() + 1];
		filename_bytes[..filename.len()].copy_from_slice(filename.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall4(
				0x118, // NR for utimensat (280 in hex)
				dfd as u64,
				filename_bytes.as_ptr() as u64,
				utimes as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call280GlassUtimensat");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 280
	
	fn glass_call281_epoll_pwait(epfd: i32, events: *mut epoll_event, maxevents: i32, timeout: i32, sigmask: *const sigset_t, sigsetsize: size_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall6(
				0x119, // NR for epoll_pwait (281 in hex)
				epfd as u64,
				events as u64,
				maxevents as u64,
				timeout as u64,
				sigmask as u64,
				sigsetsize as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call281GlassEpollPwait");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 281
	
	fn glass_call282_signalfd(ufd: i32, user_mask: *mut sigset_t, sizemask: size_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x11A, // NR for signalfd (282 in hex)
				ufd as u64,
				user_mask as u64,
				sizemask as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call282GlassSignalfd");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 282
	
	fn glass_call283_timerfd_create(clockid: i32, flags: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0x11B, // NR for timerfd_create (283 in hex)
				clockid as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call283GlassTimerfdCreate");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 283
	
	fn glass_call284_eventfd(count: c_uint) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x11C, // NR for eventfd (284 in hex)
				count as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call284GlassEventfd");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 284
	
	fn glass_call285_fallocate(fd: i32, mode: i32, offset: loff_t, len: loff_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall4(
				0x11D, // NR for fallocate (285 in hex)
				fd as u64,
				mode as u64,
				offset as u64,
				len as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call285GlassFallocate");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 285
	
	fn glass_call286_timerfd_settime(ufd: i32, flags: i32, utmr: *const __kernel_itimerspec, otmr: *mut __kernel_itimerspec) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall4(
				0x11E, // NR for timerfd_settime (286 in hex)
				ufd as u64,
				flags as u64,
				utmr as u64,
				otmr as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call286GlassTimerfdSettime");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 286
	
	fn glass_call287_timerfd_gettime(ufd: i32, otmr: *mut __kernel_itimerspec) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0x11F, // NR for timerfd_gettime (287 in hex)
				ufd as u64,
				otmr as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call287GlassTimerfdGettime");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 287
	
	fn glass_call288_accept4(sockfd: i32, addr: *mut sockaddr, addrlen: *mut i32, flags: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall4(
				0x120, // NR for accept4 (288 in hex)
				sockfd as u64,
				addr as u64,
				addrlen as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call288GlassAccept4");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 288
	
	fn glass_call289_signalfd4(ufd: i32, user_mask: *mut sigset_t, sizemask: size_t, flags: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall4(
				0x121, // NR for signalfd4 (289 in hex)
				ufd as u64,
				user_mask as u64,
				sizemask as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call289GlassSignalfd4");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 289
	
	fn glass_call290_eventfd2(count: c_uint, flags: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0x122, // NR for eventfd2 (290 in hex)
				count as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call290GlassEventfd2");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 290
	
	fn glass_call291_epoll_create1(flags: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x123, // NR for epoll_create1 (291 in hex)
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call291GlassEpollCreate1");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 291
	
	fn glass_call292_dup3(oldfd: c_uint, newfd: c_uint, flags: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x124, // NR for dup3 (292 in hex)
				oldfd as u64,
				newfd as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call292GlassDup3");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 292
	
	fn glass_call293_pipe2(fildes: *mut i32, flags: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0x125, // NR for pipe2 (293 in hex)
				fildes as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call293GlassPipe2");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 293
	
	fn glass_call294_inotify_init1(flags: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x126, // NR for inotify_init1 (294 in hex)
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call294GlassInotifyInit1");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 294
	
	fn glass_call295_preadv(fd: c_ulong, vec: *const iovec, vlen: c_ulong, pos_l: c_ulong, pos_h: c_ulong) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall5(
				0x127, // NR for preadv (295 in hex)
				fd as u64,
				vec as u64,
				vlen as u64,
				pos_l as u64,
				pos_h as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call295GlassPreadv");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 295
	
	fn glass_call296_pwritev(fd: c_ulong, vec: *const iovec, vlen: c_ulong, pos_l: c_ulong, pos_h: c_ulong) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall5(
				0x128, // NR for pwritev (296 in hex)
				fd as u64,
				vec as u64,
				vlen as u64,
				pos_l as u64,
				pos_h as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call296GlassPwritev");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 296
	
	fn glass_call297_rt_tgsigqueueinfo(tgid: pid_t, pid: pid_t, sig: i32, uinfo: *mut siginfo_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall4(
				0x129, // NR for rt_tgsigqueueinfo (297 in hex)
				tgid as u64,
				pid as u64,
				sig as u64,
				uinfo as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call297GlassRtTgsigqueueinfo");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 297
	
	fn glass_call298_perf_event_open(attr_uptr: *mut perf_event_attr, pid: pid_t, cpu: i32, group_fd: i32, flags: c_ulong) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall5(
				0x12A, // NR for perf_event_open (298 in hex)
				attr_uptr as u64,
				pid as u64,
				cpu as u64,
				group_fd as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call298GlassPerfEventOpen");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 298
	
	fn glass_call299_recvmmsg(fd: i32, msg: *mut mmsghdr, vlen: c_uint, flags: c_uint, timeout: *mut __kernel_timespec) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall5(
				0x12B, // NR for recvmmsg (299 in hex)
				fd as u64,
				msg as u64,
				vlen as u64,
				flags as u64,
				timeout as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call299GlassRecvmmsg");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 299
	
	fn glass_call300_fanotify_init(flags: c_uint, event_f_flags: c_uint) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0x12C, // NR for fanotify_init (300 in hex)
				flags as u64,
				event_f_flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call300GlassFanotifyInit");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 300
	
	fn glass_call301_fanotify_mark(fanotify_fd: i32, flags: c_uint, mask: u64, fd: i32, pathname: &str) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut pathname_bytes = alloc::vec![0u8; pathname.len() + 1];
		pathname_bytes[..pathname.len()].copy_from_slice(pathname.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall5(
				0x12D, // NR for fanotify_mark (301 in hex)
				fanotify_fd as u64,
				flags as u64,
				mask as u64,
				fd as u64,
				pathname_bytes.as_ptr() as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call301GlassFanotifyMark");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 301
	
	fn glass_call302_prlimit64(pid: pid_t, resource: c_uint, new_rlim: *const rlimit64, old_rlim: *mut rlimit64) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall4(
				0x12E, // NR for prlimit64 (302 in hex)
				pid as u64,
				resource as u64,
				new_rlim as u64,
				old_rlim as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call302GlassPrlimit64");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 302
	
	fn glass_call303_name_to_handle_at(dfd: i32, name: &str, handle: *mut file_handle, mnt_id: *mut i32, flag: i32) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut name_bytes = alloc::vec![0u8; name.len() + 1];
		name_bytes[..name.len()].copy_from_slice(name.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall5(
				0x12F, // NR for name_to_handle_at (303 in hex)
				dfd as u64,
				name_bytes.as_ptr() as u64,
				handle as u64,
				mnt_id as u64,
				flag as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call303GlassNameToHandleAt");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 303
	
	fn glass_call304_open_by_handle_at(mountdirfd: i32, handle: *mut file_handle, flags: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x130, // NR for open_by_handle_at (304 in hex)
				mountdirfd as u64,
				handle as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call304GlassOpenByHandleAt");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 304
	
	fn glass_call305_clock_adjtime(which_clock: clockid_t, tx: *mut __kernel_timex) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0x131, // NR for clock_adjtime (305 in hex)
				which_clock as u64,
				tx as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call305GlassClockAdjtime");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 305
	
	fn glass_call306_syncfs(fd: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x132, // NR for syncfs (306 in hex)
				fd as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call306GlassSyncfs");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 306
	
	fn glass_call307_sendmmsg(fd: i32, msg: *mut mmsghdr, vlen: c_uint, flags: c_uint) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall4(
				0x133, // NR for sendmmsg (307 in hex)
				fd as u64,
				msg as u64,
				vlen as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call307GlassSendmmsg");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 307
	
	fn glass_call308_setns(fd: i32, nstype: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0x134, // NR for setns (308 in hex)
				fd as u64,
				nstype as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call308GlassSetns");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 308
	
	fn glass_call309_getcpu(cpu: *mut c_uint, node: *mut c_uint, cache: *mut getcpu_cache) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x135, // NR for getcpu (309 in hex)
				cpu as u64,
				node as u64,
				cache as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call309GlassGetcpu");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 309
	
	fn glass_call310_process_vm_readv(pid: pid_t, lvec: *const iovec, liovcnt: c_ulong, rvec: *const iovec, riovcnt: c_ulong, flags: c_ulong) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall6(
				0x136, // NR for process_vm_readv (310 in hex)
				pid as u64,
				lvec as u64,
				liovcnt as u64,
				rvec as u64,
				riovcnt as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call310GlassProcessVmReadv");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 310
	
	fn glass_call311_process_vm_writev(pid: pid_t, lvec: *const iovec, liovcnt: c_ulong, rvec: *const iovec, riovcnt: c_ulong, flags: c_ulong) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall6(
				0x137, // NR for process_vm_writev (311 in hex)
				pid as u64,
				lvec as u64,
				liovcnt as u64,
				rvec as u64,
				riovcnt as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call311GlassProcessVmWritev");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 311
	
	fn glass_call312_kcmp(pid1: pid_t, pid2: pid_t, type_: i32, idx1: c_ulong, idx2: c_ulong) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall5(
				0x138, // NR for kcmp (312 in hex)
				pid1 as u64,
				pid2 as u64,
				type_ as u64,
				idx1 as u64,
				idx2 as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call312GlassKcmp");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 312
	
	fn glass_call313_finit_module(fd: i32, uargs: &str, flags: i32) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut uargs_bytes = alloc::vec![0u8; uargs.len() + 1];
		uargs_bytes[..uargs.len()].copy_from_slice(uargs.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall3(
				0x139, // NR for finit_module (313 in hex)
				fd as u64,
				uargs_bytes.as_ptr() as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call313GlassFinitModule");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 313
	
	fn glass_call314_sched_setattr(pid: pid_t, attr: *mut sched_attr, flags: c_uint) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x13A, // NR for sched_setattr (314 in hex)
				pid as u64,
				attr as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call314GlassSchedSetattr");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 314
	
	fn glass_call315_sched_getattr(pid: pid_t, attr: *mut sched_attr, size: c_uint, flags: c_uint) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall4(
				0x13B, // NR for sched_getattr (315 in hex)
				pid as u64,
				attr as u64,
				size as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call315GlassSchedGetattr");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 315
	
	fn glass_call316_renameat2(olddfd: i32, oldname: &str, newdfd: i32, newname: &str, flags: c_uint) -> Observation<i64> {
		// Create null-terminated C-style strings
		let mut oldname_bytes = alloc::vec![0u8; oldname.len() + 1];
		oldname_bytes[..oldname.len()].copy_from_slice(oldname.as_bytes());
		let mut newname_bytes = alloc::vec![0u8; newname.len() + 1];
		newname_bytes[..newname.len()].copy_from_slice(newname.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall5(
				0x13C, // NR for renameat2 (316 in hex)
				olddfd as u64,
				oldname_bytes.as_ptr() as u64,
				newdfd as u64,
				newname_bytes.as_ptr() as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call316GlassRenameat2");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 316
	
	fn glass_call317_seccomp(op: c_uint, flags: c_uint, uargs: *mut c_void) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x13D, // NR for seccomp (317 in hex)
				op as u64,
				flags as u64,
				uargs as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call317GlassSeccomp");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 317
	
	fn glass_call318_getrandom(buf: *mut c_char, count: size_t, flags: c_uint) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x13E, // NR for getrandom (318 in hex)
				buf as u64,
				count as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call318GlassGetrandom");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 318
	
	fn glass_call319_memfd_create(uname_ptr: &str, flags: c_uint) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut uname_bytes = alloc::vec![0u8; uname_ptr.len() + 1];
		uname_bytes[..uname_ptr.len()].copy_from_slice(uname_ptr.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall2(
				0x13F, // NR for memfd_create (319 in hex)
				uname_bytes.as_ptr() as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call319GlassMemfdCreate");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 319
	
	fn glass_call320_kexec_file_load(kernel_fd: i32, initrd_fd: i32, cmdline_len: c_ulong, cmdline_ptr: &str, flags: c_ulong) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut cmdline_bytes = alloc::vec![0u8; cmdline_ptr.len() + 1];
		cmdline_bytes[..cmdline_ptr.len()].copy_from_slice(cmdline_ptr.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall5(
				0x140, // NR for kexec_file_load (320 in hex)
				kernel_fd as u64,
				initrd_fd as u64,
				cmdline_len as u64,
				cmdline_bytes.as_ptr() as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call320GlassKexecFileLoad");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 320
	
	fn glass_call321_bpf(cmd: i32, attr: *mut bpf_attr, size: c_uint) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x141, // NR for bpf (321 in hex)
				cmd as u64,
				attr as u64,
				size as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call321GlassBpf");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 321
	
	fn glass_call322_execveat(dfd: i32, filename: &str, argv: *const *const c_char, envp: *const *const c_char, flags: i32) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut filename_bytes = alloc::vec![0u8; filename.len() + 1];
		filename_bytes[..filename.len()].copy_from_slice(filename.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall5(
				0x142, // NR for execveat (322 in hex)
				dfd as u64,
				filename_bytes.as_ptr() as u64,
				argv as u64,
				envp as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call322GlassExecveat");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 322
	
	fn glass_call323_userfaultfd(flags: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x143, // NR for userfaultfd (323 in hex)
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call323GlassUserfaultfd");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 323
	
	fn glass_call324_membarrier(cmd: i32, flags: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0x144, // NR for membarrier (324 in hex)
				cmd as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call324GlassMembarrier");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 324
	
	fn glass_call325_mlock2(start: c_ulong, len: size_t, flags: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall3(
				0x145, // NR for mlock2 (325 in hex)
				start as u64,
				len as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call325GlassMlock2");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 325
	
	fn glass_call326_copy_file_range(fd_in: i32, off_in: *mut loff_t, fd_out: i32, off_out: *mut loff_t, len: size_t, flags: c_uint) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall6(
				0x146, // NR for copy_file_range (326 in hex)
				fd_in as u64,
				off_in as u64,
				fd_out as u64,
				off_out as u64,
				len as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call326GlassCopyFileRange");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 326
	
	fn glass_call327_preadv2(fd: c_ulong, vec: *const iovec, vlen: c_ulong, pos_l: c_ulong, pos_h: c_ulong, flags: rwf_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall6(
				0x147, // NR for preadv2 (327 in hex)
				fd as u64,
				vec as u64,
				vlen as u64,
				pos_l as u64,
				pos_h as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call327GlassPreadv2");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 327
	
	fn glass_call328_pwritev2(fd: c_ulong, vec: *const iovec, vlen: c_ulong, pos_l: c_ulong, pos_h: c_ulong, flags: rwf_t) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall6(
				0x148, // NR for pwritev2 (328 in hex)
				fd as u64,
				vec as u64,
				vlen as u64,
				pos_l as u64,
				pos_h as u64,
				flags as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call328GlassPwritev2");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 328
	
	fn glass_call329_pkey_mprotect(start: c_ulong, len: size_t, prot: c_ulong, pkey: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall4(
				0x149, // NR for pkey_mprotect (329 in hex)
				start as u64,
				len as u64,
				prot as u64,
				pkey as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call329GlassPkeyMprotect");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 329
	
	fn glass_call330_pkey_alloc(flags: c_ulong, init_val: c_ulong) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall2(
				0x14A, // NR for pkey_alloc (330 in hex)
				flags as u64,
				init_val as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call330GlassPkeyAlloc");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 330
	
	fn glass_call331_pkey_free(pkey: i32) -> Observation<i64> {
		let result = unsafe {
			Self::raw_syscall1(
				0x14B, // NR for pkey_free (331 in hex)
				pkey as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call331GlassPkeyFree");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 331
	
	fn glass_call332_statx(dfd: i32, path: &str, flags: c_uint, mask: c_uint, buffer: *mut statx) -> Observation<i64> {
		// Create null-terminated C-style string
		let mut path_bytes = alloc::vec![0u8; path.len() + 1];
		path_bytes[..path.len()].copy_from_slice(path.as_bytes());
		
		let result = unsafe {
			Self::raw_syscall5(
				0x14C, // NR for statx (332 in hex)
				dfd as u64,
				path_bytes.as_ptr() as u64,
				flags as u64,
				mask as u64,
				buffer as u64,
			)
		};
		
		let segment = &TopologySegment::new("Daemonic::Glass::DaemonicSystemCall::Call332GlassStatx");
		if result < 0 {
			Self::escalate(result as i32)
		} else {
			Observation::stable(result, segment)
		}
	} // NR 332
}
/// N.B., for LLVM to recognize the void pointer type and by extension
///     functions like malloc(), we need to have it represented as i8* in
///     LLVM bitcode. The enum used here ensures this and prevents misuse
///     of the "raw" type by only having private variants. We need two
///     variants, because the compiler complains about the repr attribute
///     otherwise and we need at least one variant as otherwise the enum
///     would be uninhabited and at least dereferencing such pointers would
///     be UB.
#[cfg_attr(not(doc), repr(u8))]
pub enum DaemonicCvoid {
	#[allow(non_camel_case_types)]
	__variant1,
	#[allow(non_camel_case_types)]
	__variant2,
}
unsafe impl DaemonicSystemCall for DaemonicCvoid {}
impl SymbolicAnchor for DaemonicCvoid {
	fn meaningful_within(&self) -> impl ReferenceFrame {
		todo!()
	}
}

impl Anchor for DaemonicCvoid {
	fn anchor_domains(&self) -> AnchorDomainSet {
		todo!()
	}
}

impl SemanticAnchor for DaemonicCvoid {}
impl Debug for DaemonicCvoid {
	fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), core::fmt::Error> {
		// todo debug_struct function and shit needs to be imported and rewritten
		f.debug_struct("DaemonicCvoid").finish()
	}
}
static SYSCALL_ERR_SEGMENT: TopologySegment = TopologySegment {
	label: "Daemonic::Glass::SystemCall::Error",
	hash: const_daemonic_hash("Daemonic::Glass::SystemCall::Error".as_bytes(), 0x4441454D4F4E4943),
	crypto_id: const_daemonic_hash("Daemonic::Glass::SystemCall".as_bytes(), AXIOM_OFFSET),
	depth: 3u16,
};

use crate::{const_daemonic_hash, DaemonicError, AXIOM_OFFSET};
use crate::daemonic::frame::ReferenceFrame;
use crate::daemonic::glass::Severity::{Echo, Fracture};
use crate::daemonic::glass::error::{Error, daemonic::glass, *};
use crate::daemonic::glass::FidelityAction::Continue;
use crate::daemonic::glass::states::ImpossibleSource::Observer;
use crate::daemonic::observation::observable::Observable;