From cf23eabba38ec21afecafe196cbc70830abb0674 Mon Sep 17 00:00:00 2001 From: rkx1209 Date: Tue, 2 Jan 2018 00:19:54 +0900 Subject: [PATCH] Add test framework based on libtransisotr(Reswithed Team works) --- .gitmodules | 3 + Makefile | 4 + test/Makefile | 85 + test/include/libtransistor/err.h | 41 + test/include/libtransistor/ipc.h | 92 + test/include/libtransistor/ipc/bsd.h | 31 + test/include/libtransistor/ipc/sm.h | 7 + test/include/libtransistor/nx.h | 22 + test/include/libtransistor/stb_sprintf.h | 1812 ++ test/include/libtransistor/svc.h | 122 + test/include/libtransistor/tls.h | 3 + test/include/libtransistor/types.h | 73 + test/include/libtransistor/util.h | 15 + test/lib/crt0.nro.S | 58 + test/lib/crt0.nso.S | 42 + test/lib/ipc.c | 526 + test/lib/ipc/bsd.c | 850 + test/lib/ipc/sm.c | 59 + test/lib/ipcClients.h | 27871 +++++++++++++++++++++ test/lib/svc.S | 240 + test/lib/tls.S | 5 + test/lib/util.c | 104 + test/link.T | 71 + test/newlib | 1 + test/requirements.txt | 2 + test/test.txt | 1 + test/test/test_bsd.c | 154 + test/test/test_bsd_ai_packing.c | 89 + test/test/test_malloc.c | 16 + test/test/test_sfdnsres.c | 76 + test/test_helpers/bsd.rb | 43 + test/tools/elf2nxo.py | 115 + test/tools/generateIpcClients.py | 320 + 33 files changed, 32953 insertions(+) create mode 100644 .gitmodules create mode 100644 test/Makefile create mode 100644 test/include/libtransistor/err.h create mode 100644 test/include/libtransistor/ipc.h create mode 100644 test/include/libtransistor/ipc/bsd.h create mode 100644 test/include/libtransistor/ipc/sm.h create mode 100644 test/include/libtransistor/nx.h create mode 100644 test/include/libtransistor/stb_sprintf.h create mode 100644 test/include/libtransistor/svc.h create mode 100644 test/include/libtransistor/tls.h create mode 100644 test/include/libtransistor/types.h create mode 100644 test/include/libtransistor/util.h create mode 100644 test/lib/crt0.nro.S create mode 100644 test/lib/crt0.nso.S create mode 100644 test/lib/ipc.c create mode 100644 test/lib/ipc/bsd.c create mode 100644 test/lib/ipc/sm.c create mode 100644 test/lib/ipcClients.h create mode 100644 test/lib/svc.S create mode 100644 test/lib/tls.S create mode 100644 test/lib/util.c create mode 100644 test/link.T create mode 160000 test/newlib create mode 100644 test/requirements.txt create mode 100644 test/test.txt create mode 100644 test/test/test_bsd.c create mode 100644 test/test/test_bsd_ai_packing.c create mode 100644 test/test/test_malloc.c create mode 100644 test/test/test_sfdnsres.c create mode 100644 test/test_helpers/bsd.rb create mode 100644 test/tools/elf2nxo.py create mode 100644 test/tools/generateIpcClients.py diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..179f0a1 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "test/newlib"] + path = test/newlib + url = https://github.com/reswitched/newlib diff --git a/Makefile b/Makefile index 243f355..5b79ddf 100644 --- a/Makefile +++ b/Makefile @@ -3,12 +3,16 @@ SRC_FILES := $(wildcard *.cpp ARMv8/*.cpp) OBJ_FILES := $(SRC_FILES:.cpp=.o) CXX_FLAGS := -std=c++11 -Iinclude LD_FLAGS := -llz4 -lpthread +MAKE := make all: nsemu nsemu: $(OBJ_FILES) $(CXX) -o nsemu $(OBJ_FILES) $(LD_FLAGS) %.o: %.cpp $(CXX) $(CXX_FLAGS) -c -g -o $@ $< +testall: + $(MAKE) -C test/ clean: + $(MAKE) clean -C test/ rm -f *.o */*.o rm -f nsemu diff --git a/test/Makefile b/test/Makefile new file mode 100644 index 0000000..ced9809 --- /dev/null +++ b/test/Makefile @@ -0,0 +1,85 @@ +LD := ld.lld +CC := clang +AS := llvm-mc +LD_FLAGS := -Bsymbolic --shared --no-gc-sections --no-undefined -T link.T +CC_FLAGS := -g -fPIC -ffreestanding -fexceptions -target aarch64-none-linux-gnu -O0 -mtune=cortex-a53 -I include/ -I newlib/newlib/libc/include/ -I newlib/newlib/libc/sys/switch/include/ +AS_FLAGS := -arch=aarch64 -triple aarch64-none-switch +PYTHON2 := python2 +MEPHISTO := ctu +RUBY := ruby + +libtransistor_TESTS := malloc bsd_ai_packing bsd sfdnsres + +libtransistor_OBJECTS := build/lib/svc.o build/lib/ipc.o build/lib/tls.o build/lib/util.o build/lib/ipc/sm.o build/lib/ipc/bsd.o + +# for building newlib +export AR_FOR_TARGET = llvm-ar +export AS_FOR_TARGET = llvm-mc -arch=aarch64 -mattr=+neon +export LD_FOR_TARGET = ld.lld +export RANLIB_FOR_TARGET = llvm-ranlib +export CC_FOR_TARGET = clang -g -fPIC -ffreestanding -fexceptions -target aarch64-none-linux-gnu -O0 -mtune=cortex-a53 -ccc-gcc-name aarch64-switch-gcc -Wno-unused-command-line-argument + +.SUFFIXES: # disable built-in rules + +all: build/lib/libtransistor.nro.a build/lib/libtransistor.nso.a $(addprefix build/test/test_,$(addsuffix .nro,$(libtransistor_TESTS))) $(addprefix build/test/test_,$(addsuffix .nso,$(libtransistor_TESTS))) $(addprefix build/test/test_,$(addsuffix .nro.so,$(libtransistor_TESTS))) $(addprefix build/test/test_,$(addsuffix .nso.so,$(libtransistor_TESTS))) + +run_tests: run_malloc_test run_bsd_ai_packing_test run_bsd_test run_sfdnsres_test + +run_bsd_test: build/test/test_bsd.nro test_helpers/bsd.rb + $(RUBY) test_helpers/bsd.rb $(MEPHISTO) + +run_sfdnsres_test: build/test/test_sfdnsres.nro + $(MEPHISTO) --enable-sockets --load-nro $< + +run_%_test: build/test/test_%.nro + $(MEPHISTO) --load-nro $< + +build/test/%.o: test/%.c + mkdir -p $(@D) + $(CC) $(CC_FLAGS) -c -o $@ $< + +build/lib/%.o: lib/%.c + mkdir -p $(@D) + $(CC) $(CC_FLAGS) -c -o $@ $< + +build/lib/%.o: lib/%.S + mkdir -p $(@D) + $(AS) $(AS_FLAGS) $< -filetype=obj -o $@ + +build/test/%.nro: build/test/%.nro.so + mkdir -p $(@D) + $(PYTHON2) ./tools/elf2nxo.py $< $@ nro + +build/test/%.nso: build/test/%.nso.so + mkdir -p $(@D) + $(PYTHON2) ./tools/elf2nxo.py $< $@ nso + +build/test/%.nro.so: build/test/%.o build/lib/libtransistor.nro.a newlib/aarch64-none-switch/newlib/libc.a + mkdir -p $(@D) + $(LD) $(LD_FLAGS) -o $@ $< --whole-archive build/lib/libtransistor.nro.a --no-whole-archive newlib/aarch64-none-switch/newlib/libc.a + +build/test/%.nso.so: build/test/%.o build/lib/libtransistor.nso.a newlib/aarch64-none-switch/newlib/libc.a + mkdir -p $(@D) + $(LD) $(LD_FLAGS) -o $@ $< --whole-archive build/lib/libtransistor.nso.a --no-whole-archive newlib/aarch64-none-switch/newlib/libc.a + +build/lib/libtransistor.nro.a: build/lib/crt0.nro.o $(libtransistor_OBJECTS) + mkdir -p $(@D) + rm -f $@ + ar rcs $@ $+ + +build/lib/libtransistor.nso.a: build/lib/crt0.nso.o $(libtransistor_OBJECTS) + mkdir -p $(@D) + rm -f $@ + ar rcs $@ $+ + +newlib/Makefile: + cd newlib; ./configure --target=aarch64-none-switch --without-rdimon + +newlib/aarch64-none-switch/newlib/libc.a: newlib/Makefile + make -C newlib/ + +newlib/aarch64-none-switch/libgloss/libnosys/libnosys.a: newlib/aarch64-none-switch/newlib/libc.a +newlib/aarch64-none-switch/libgloss/aarch64/librdimon.a: newlib/aarch64-none-switch/newlib/libc.a + +clean: + rm -rf build/lib/* build/test/* diff --git a/test/include/libtransistor/err.h b/test/include/libtransistor/err.h new file mode 100644 index 0000000..91cba1a --- /dev/null +++ b/test/include/libtransistor/err.h @@ -0,0 +1,41 @@ +#pragma once + +#define LIBTRANSISTOR_RESULT(code) (((code) << 8) | 0xDD) + +// Misc +#define LIBTRANSISTOR_ERR_UNSPECIFIED LIBTRANSISTOR_RESULT(1) +#define LIBTRANSISTOR_ERR_UNIMPLEMENTED LIBTRANSISTOR_RESULT(2) +#define LIBTRANSISTOR_ERR_OUT_OF_MEMORY LIBTRANSISTOR_RESULT(3) + +// IPC +#define LIBTRANSISTOR_ERR_UNSUPPORTED_BUFFER_TYPE LIBTRANSISTOR_RESULT(1001) +#define LIBTRANSISTOR_ERR_TOO_MANY_BUFFERS LIBTRANSISTOR_RESULT(1002) +#define LIBTRANSISTOR_ERR_INVALID_REQUEST_TYPE LIBTRANSISTOR_RESULT(1003) +#define LIBTRANSISTOR_ERR_TOO_MANY_HANDLES LIBTRANSISTOR_RESULT(1004) +#define LIBTRANSISTOR_ERR_INVALID_BUFFER_ADDRESS LIBTRANSISTOR_RESULT(1005) +#define LIBTRANSISTOR_ERR_INVALID_BUFFER_SIZE LIBTRANSISTOR_RESULT(1006) +#define LIBTRANSISTOR_ERR_INVALID_PROTECTION LIBTRANSISTOR_RESULT(1007) +#define LIBTRANSISTOR_ERR_INVALID_IPC_RESPONSE_TYPE LIBTRANSISTOR_RESULT(1008) +#define LIBTRANSISTOR_ERR_INVALID_IPC_RESPONSE_MAGIC LIBTRANSISTOR_RESULT(1009) +#define LIBTRANSISTOR_ERR_INVALID_RAW_DATA_SIZE LIBTRANSISTOR_RESULT(1010) +#define LIBTRANSISTOR_ERR_UNEXPECTED_RAW_DATA_SIZE LIBTRANSISTOR_RESULT(1011) +#define LIBTRANSISTOR_ERR_UNEXPECTED_PID LIBTRANSISTOR_RESULT(1012) +#define LIBTRANSISTOR_ERR_UNEXPECTED_COPY_HANDLES LIBTRANSISTOR_RESULT(1013) +#define LIBTRANSISTOR_ERR_UNEXPECTED_MOVE_HANDLES LIBTRANSISTOR_RESULT(1014) +#define LIBTRANSISTOR_ERR_ALREADY_A_DOMAIN LIBTRANSISTOR_RESULT(1015) +#define LIBTRANSISTOR_ERR_CANT_SEND_OBJECT_ACROSS_DOMAINS LIBTRANSISTOR_RESULT(1016) +#define LIBTRANSISTOR_ERR_CANT_SEND_DOMAIN_OBJECT_TO_SESSION LIBTRANSISTOR_RESULT(1017) +#define LIBTRANSISTOR_ERR_TOO_MANY_OBJECTS LIBTRANSISTOR_RESULT(1018) +#define LIBTRANSISTOR_ERR_UNEXPECTED_DOMAIN_HEADER_COMMAND LIBTRANSISTOR_RESULT(1018) +#define LIBTRANSISTOR_ERR_UNEXPECTED_OBJECTS LIBTRANSISTOR_RESULT(1019) +#define LIBTRANSISTOR_ERR_CANT_CLOSE_SESSIONS_LIKE_DOMAIN_OBJECTS LIBTRANSISTOR_RESULT(1020) +#define LIBTRANSISTOR_ERR_MALFORMED_CLOSE_REQUEST LIBTRANSISTOR_RESULT(1021) + +// SM +#define LIBTRANSISTOR_ERR_SM_NOT_INITIALIZED LIBTRANSISTOR_RESULT(2001) +#define LIBTRANSISTOR_ERR_SM_SERVICE_NAME_TOO_LONG LIBTRANSISTOR_RESULT(2002) + +// BSD +#define LIBTRANSISTOR_ERR_BSD_ERRNO_SET LIBTRANSISTOR_RESULT(3001) +#define LIBTRANSISTOR_ERR_BSD_BUFFER_TOO_SMALL LIBTRANSISTOR_RESULT(3002) +#define LIBTRANSISTOR_ERR_BSD_INVALID_MAGIC LIBTRANSISTOR_RESULT(3003) diff --git a/test/include/libtransistor/ipc.h b/test/include/libtransistor/ipc.h new file mode 100644 index 0000000..3fe284b --- /dev/null +++ b/test/include/libtransistor/ipc.h @@ -0,0 +1,92 @@ +#pragma once + +#include + +typedef struct { + session_h session; +} ipc_domain_t; + +typedef struct { + int32_t object_id; // -1 if this represents a session, >= 0 if this represents a domain object + union { + session_h session; // object_id = -1 + ipc_domain_t *domain; // object_id >= 0 + }; +} ipc_object_t; + +typedef struct { + void *addr; + u64 size; + u32 type; +} ipc_buffer_t; + +typedef struct { + u32 type; + u32 num_buffers; + ipc_buffer_t **buffers; + u32 request_id; + u32 *raw_data; + u64 raw_data_size; // in BYTES + bool send_pid; + u8 num_copy_handles; + u8 num_move_handles; + u8 num_objects; + handle_t *copy_handles; + handle_t *move_handles; + ipc_object_t *objects; + bool close_object; +} ipc_request_t; + +// fill this struct out with what you expect before passing it to ipc_unmarshal +typedef struct { + int num_copy_handles; + int num_move_handles; + int num_objects; + handle_t *copy_handles; + handle_t *move_handles; + ipc_object_t *objects; + + int raw_data_size; // in BYTES + u32 *raw_data; + + bool has_pid; + u32 *pid; +} ipc_response_fmt_t; + +// see ipc.c for actual default values +extern ipc_request_t ipc_default_request; +extern ipc_response_fmt_t ipc_default_response_fmt; +extern ipc_object_t ipc_null_object; + +/* + Packs the IPC message described by `rq` and `object` into `buffer`. + */ +result_t ipc_marshal(u32 *buffer, ipc_request_t *rq, ipc_object_t object); + +/* + Unpacks the IPC message described by `rs` from `buffer`. `object` should + be the object the request was sent to. + */ +result_t ipc_unmarshal(u32 *buffer, ipc_response_fmt_t *rs, ipc_object_t object); + +/* + Send a request described by `rq` to `object` and then unpack the response + */ +result_t ipc_send(ipc_object_t object, ipc_request_t *rq, ipc_response_fmt_t *rs); + +/* + Converts `session` to a domain object and initializes `domain`. + Guarenteed to initialize `domain`, making it valid to call `ipc_close_domain` + on the newly initialized domain if this returns != RESULT_OK + */ +result_t ipc_convert_to_domain(ipc_object_t *session, ipc_domain_t *domain); + +/* + Closes the `object` + */ +result_t ipc_close(ipc_object_t object); + +/* + Closes the whole `domain` +*/ +result_t ipc_close_domain(ipc_domain_t domain); diff --git a/test/include/libtransistor/ipc/bsd.h b/test/include/libtransistor/ipc/bsd.h new file mode 100644 index 0000000..148a62c --- /dev/null +++ b/test/include/libtransistor/ipc/bsd.h @@ -0,0 +1,31 @@ +#pragma once + +#include +#include +#include +#include +#include + +extern result_t bsd_result; +extern int bsd_errno; + +result_t bsd_init(); +int bsd_socket(int domain, int type, int protocol); +int bsd_recv(int socket, void *message, size_t length, int flags); +int bsd_send(int socket, const void *data, size_t length, int flags); +int bsd_sendto(int socket, const void *message, size_t length, int flags, const struct sockaddr *dest_addr, socklen_t dest_len); +int bsd_accept(int socket, struct sockaddr *restrict address, socklen_t *restrict address_len); +int bsd_bind(int socket, const struct sockaddr *address, socklen_t address_len); +int bsd_connect(int socket, const struct sockaddr *address, socklen_t address_len); +int bsd_getsockname(int socket, struct sockaddr *restrict address, socklen_t *restrict address_len); +int bsd_listen(int socket, int backlog); +int bsd_setsockopt(int socket, int level, int option_name, const void *option_value, socklen_t option_len); +int bsd_shutdown(int socket, int how); +int bsd_select(int nfds, fd_set *restrict readfds, fd_set *restrict writefds, fd_set *restrict errorfds, struct timeval *restrict timeout); +int bsd_getaddrinfo(const char *node, const char *service, const struct addrinfo *hints, struct addrinfo **res); +void bsd_freeaddrinfo(struct addrinfo *res); +int bsd_close(int socket); +void bsd_finalize(); + +result_t bsd_ai_pack(const struct addrinfo *ai, uint8_t *buf, int size); +result_t bsd_ai_unpack(struct addrinfo **ai, const uint8_t *buf, int size); diff --git a/test/include/libtransistor/ipc/sm.h b/test/include/libtransistor/ipc/sm.h new file mode 100644 index 0000000..0e4dc03 --- /dev/null +++ b/test/include/libtransistor/ipc/sm.h @@ -0,0 +1,7 @@ +#pragma once + +#include + +result_t sm_init(); +result_t sm_get_service(ipc_object_t *session, char *name); +void sm_finalize(); diff --git a/test/include/libtransistor/nx.h b/test/include/libtransistor/nx.h new file mode 100644 index 0000000..b5f81da --- /dev/null +++ b/test/include/libtransistor/nx.h @@ -0,0 +1,22 @@ +/** + * @file switch.h + * @brief Central Switch header. Includes all others. + */ + +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +} +#endif diff --git a/test/include/libtransistor/stb_sprintf.h b/test/include/libtransistor/stb_sprintf.h new file mode 100644 index 0000000..450897e --- /dev/null +++ b/test/include/libtransistor/stb_sprintf.h @@ -0,0 +1,1812 @@ +// stb_sprintf - v1.03 - public domain snprintf() implementation +// originally by Jeff Roberts / RAD Game Tools, 2015/10/20 +// http://github.com/nothings/stb +// +// allowed types: sc uidBboXx p AaGgEef n +// lengths : h ll j z t I64 I32 I +// +// Contributors: +// Fabian "ryg" Giesen (reformatting) +// +// Contributors (bugfixes): +// github:d26435 +// github:trex78 +// Jari Komppa (SI suffixes) +// +// LICENSE: +// +// See end of file for license information. + +#ifndef STB_SPRINTF_H_INCLUDE +#define STB_SPRINTF_H_INCLUDE + +/* +Single file sprintf replacement. + +Originally written by Jeff Roberts at RAD Game Tools - 2015/10/20. +Hereby placed in public domain. + +This is a full sprintf replacement that supports everything that +the C runtime sprintfs support, including float/double, 64-bit integers, +hex floats, field parameters (%*.*d stuff), length reads backs, etc. + +Why would you need this if sprintf already exists? Well, first off, +it's *much* faster (see below). It's also much smaller than the CRT +versions code-space-wise. We've also added some simple improvements +that are super handy (commas in thousands, callbacks at buffer full, +for example). Finally, the format strings for MSVC and GCC differ +for 64-bit integers (among other small things), so this lets you use +the same format strings in cross platform code. + +It uses the standard single file trick of being both the header file +and the source itself. If you just include it normally, you just get +the header file function definitions. To get the code, you include +it from a C or C++ file and define STB_SPRINTF_IMPLEMENTATION first. + +It only uses va_args macros from the C runtime to do it's work. It +does cast doubles to S64s and shifts and divides U64s, which does +drag in CRT code on most platforms. + +It compiles to roughly 8K with float support, and 4K without. +As a comparison, when using MSVC static libs, calling sprintf drags +in 16K. + +API: +==== +int stbsp_sprintf( char * buf, char const * fmt, ... ) +int stbsp_snprintf( char * buf, int count, char const * fmt, ... ) + Convert an arg list into a buffer. stbsp_snprintf always returns + a zero-terminated string (unlike regular snprintf). + +int stbsp_vsprintf( char * buf, char const * fmt, va_list va ) +int stbsp_vsnprintf( char * buf, int count, char const * fmt, va_list va ) + Convert a va_list arg list into a buffer. stbsp_vsnprintf always returns + a zero-terminated string (unlike regular snprintf). + +int stbsp_vsprintfcb( STBSP_SPRINTFCB * callback, void * user, char * buf, char const * fmt, va_list va ) + typedef char * STBSP_SPRINTFCB( char const * buf, void * user, int len ); + Convert into a buffer, calling back every STB_SPRINTF_MIN chars. + Your callback can then copy the chars out, print them or whatever. + This function is actually the workhorse for everything else. + The buffer you pass in must hold at least STB_SPRINTF_MIN characters. + // you return the next buffer to use or 0 to stop converting + +void stbsp_set_separators( char comma, char period ) + Set the comma and period characters to use. + +FLOATS/DOUBLES: +=============== +This code uses a internal float->ascii conversion method that uses +doubles with error correction (double-doubles, for ~105 bits of +precision). This conversion is round-trip perfect - that is, an atof +of the values output here will give you the bit-exact double back. + +One difference is that our insignificant digits will be different than +with MSVC or GCC (but they don't match each other either). We also +don't attempt to find the minimum length matching float (pre-MSVC15 +doesn't either). + +If you don't need float or doubles at all, define STB_SPRINTF_NOFLOAT +and you'll save 4K of code space. + +64-BIT INTS: +============ +This library also supports 64-bit integers and you can use MSVC style or +GCC style indicators (%I64d or %lld). It supports the C99 specifiers +for size_t and ptr_diff_t (%jd %zd) as well. + +EXTRAS: +======= +Like some GCCs, for integers and floats, you can use a ' (single quote) +specifier and commas will be inserted on the thousands: "%'d" on 12345 +would print 12,345. + +For integers and floats, you can use a "$" specifier and the number +will be converted to float and then divided to get kilo, mega, giga or +tera and then printed, so "%$d" 1000 is "1.0 k", "%$.2d" 2536000 is +"2.53 M", etc. For byte values, use two $:s, like "%$$d" to turn +2536000 to "2.42 Mi". If you prefer JEDEC suffixes to SI ones, use three +$:s: "%$$$d" -> "2.42 M". To remove the space between the number and the +suffix, add "_" specifier: "%_$d" -> "2.53M". + +In addition to octal and hexadecimal conversions, you can print +integers in binary: "%b" for 256 would print 100. + +PERFORMANCE vs MSVC 2008 32-/64-bit (GCC is even slower than MSVC): +=================================================================== +"%d" across all 32-bit ints (4.8x/4.0x faster than 32-/64-bit MSVC) +"%24d" across all 32-bit ints (4.5x/4.2x faster) +"%x" across all 32-bit ints (4.5x/3.8x faster) +"%08x" across all 32-bit ints (4.3x/3.8x faster) +"%f" across e-10 to e+10 floats (7.3x/6.0x faster) +"%e" across e-10 to e+10 floats (8.1x/6.0x faster) +"%g" across e-10 to e+10 floats (10.0x/7.1x faster) +"%f" for values near e-300 (7.9x/6.5x faster) +"%f" for values near e+300 (10.0x/9.1x faster) +"%e" for values near e-300 (10.1x/7.0x faster) +"%e" for values near e+300 (9.2x/6.0x faster) +"%.320f" for values near e-300 (12.6x/11.2x faster) +"%a" for random values (8.6x/4.3x faster) +"%I64d" for 64-bits with 32-bit values (4.8x/3.4x faster) +"%I64d" for 64-bits > 32-bit values (4.9x/5.5x faster) +"%s%s%s" for 64 char strings (7.1x/7.3x faster) +"...512 char string..." ( 35.0x/32.5x faster!) +*/ + +#if defined(__has_feature) + #if __has_feature(address_sanitizer) + #define STBI__ASAN __attribute__((no_sanitize("address"))) + #endif +#endif +#ifndef STBI__ASAN +#define STBI__ASAN +#endif + +#ifdef STB_SPRINTF_STATIC +#define STBSP__PUBLICDEC static +#define STBSP__PUBLICDEF static STBI__ASAN +#else +#ifdef __cplusplus +#define STBSP__PUBLICDEC extern "C" +#define STBSP__PUBLICDEF extern "C" STBI__ASAN +#else +#define STBSP__PUBLICDEC extern +#define STBSP__PUBLICDEF STBI__ASAN +#endif +#endif + +#include // for va_list() + +#ifndef STB_SPRINTF_MIN +#define STB_SPRINTF_MIN 512 // how many characters per callback +#endif +typedef char *STBSP_SPRINTFCB(char *buf, void *user, int len); + +#ifndef STB_SPRINTF_DECORATE +#define STB_SPRINTF_DECORATE(name) stbsp_##name // define this before including if you want to change the names +#endif + +STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(vsprintf)(char *buf, char const *fmt, va_list va); +STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(vsnprintf)(char *buf, int count, char const *fmt, va_list va); +STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(sprintf)(char *buf, char const *fmt, ...); +STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(snprintf)(char *buf, int count, char const *fmt, ...); + +STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(vsprintfcb)(STBSP_SPRINTFCB *callback, void *user, char *buf, char const *fmt, va_list va); +STBSP__PUBLICDEF void STB_SPRINTF_DECORATE(set_separators)(char comma, char period); + +#endif // STB_SPRINTF_H_INCLUDE + +#ifdef STB_SPRINTF_IMPLEMENTATION + +#include // for va_arg() + +#define stbsp__uint32 unsigned int +#define stbsp__int32 signed int + +#ifdef _MSC_VER +#define stbsp__uint64 unsigned __int64 +#define stbsp__int64 signed __int64 +#else +#define stbsp__uint64 unsigned long long +#define stbsp__int64 signed long long +#endif +#define stbsp__uint16 unsigned short + +#ifndef stbsp__uintptr +#if defined(__ppc64__) || defined(__aarch64__) || defined(_M_X64) || defined(__x86_64__) || defined(__x86_64) +#define stbsp__uintptr stbsp__uint64 +#else +#define stbsp__uintptr stbsp__uint32 +#endif +#endif + +#ifndef STB_SPRINTF_MSVC_MODE // used for MSVC2013 and earlier (MSVC2015 matches GCC) +#if defined(_MSC_VER) && (_MSC_VER < 1900) +#define STB_SPRINTF_MSVC_MODE +#endif +#endif + +#ifdef STB_SPRINTF_NOUNALIGNED // define this before inclusion to force stbsp_sprintf to always use aligned accesses +#define STBSP__UNALIGNED(code) +#else +#define STBSP__UNALIGNED(code) code +#endif + +#ifndef STB_SPRINTF_NOFLOAT +// internal float utility functions +static stbsp__int32 stbsp__real_to_str(char const **start, stbsp__uint32 *len, char *out, stbsp__int32 *decimal_pos, double value, stbsp__uint32 frac_digits); +static stbsp__int32 stbsp__real_to_parts(stbsp__int64 *bits, stbsp__int32 *expo, double value); +#define STBSP__SPECIAL 0x7000 +#endif + +static char stbsp__period = '.'; +static char stbsp__comma = ','; +static char stbsp__digitpair[201] = + "0001020304050607080910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576" + "7778798081828384858687888990919293949596979899"; + +STBSP__PUBLICDEF void STB_SPRINTF_DECORATE(set_separators)(char pcomma, char pperiod) +{ + stbsp__period = pperiod; + stbsp__comma = pcomma; +} + +#define STBSP__LEFTJUST 1 +#define STBSP__LEADINGPLUS 2 +#define STBSP__LEADINGSPACE 4 +#define STBSP__LEADING_0X 8 +#define STBSP__LEADINGZERO 16 +#define STBSP__INTMAX 32 +#define STBSP__TRIPLET_COMMA 64 +#define STBSP__NEGATIVE 128 +#define STBSP__METRIC_SUFFIX 256 +#define STBSP__HALFWIDTH 512 +#define STBSP__METRIC_NOSPACE 1024 +#define STBSP__METRIC_1024 2048 +#define STBSP__METRIC_JEDEC 4096 + +static void stbsp__lead_sign(stbsp__uint32 fl, char *sign) +{ + sign[0] = 0; + if (fl & STBSP__NEGATIVE) { + sign[0] = 1; + sign[1] = '-'; + } else if (fl & STBSP__LEADINGSPACE) { + sign[0] = 1; + sign[1] = ' '; + } else if (fl & STBSP__LEADINGPLUS) { + sign[0] = 1; + sign[1] = '+'; + } +} + +STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(vsprintfcb)(STBSP_SPRINTFCB *callback, void *user, char *buf, char const *fmt, va_list va) +{ + static char hex[] = "0123456789abcdefxp"; + static char hexu[] = "0123456789ABCDEFXP"; + char *bf; + char const *f; + int tlen = 0; + + bf = buf; + f = fmt; + for (;;) { + stbsp__int32 fw, pr, tz; + stbsp__uint32 fl; + + // macros for the callback buffer stuff + #define stbsp__chk_cb_bufL(bytes) \ + { \ + int len = (int)(bf - buf); \ + if ((len + (bytes)) >= STB_SPRINTF_MIN) { \ + tlen += len; \ + if (0 == (bf = buf = callback(buf, user, len))) \ + goto done; \ + } \ + } + #define stbsp__chk_cb_buf(bytes) \ + { \ + if (callback) { \ + stbsp__chk_cb_bufL(bytes); \ + } \ + } + #define stbsp__flush_cb() \ + { \ + stbsp__chk_cb_bufL(STB_SPRINTF_MIN - 1); \ + } // flush if there is even one byte in the buffer + #define stbsp__cb_buf_clamp(cl, v) \ + cl = v; \ + if (callback) { \ + int lg = STB_SPRINTF_MIN - (int)(bf - buf); \ + if (cl > lg) \ + cl = lg; \ + } + + // fast copy everything up to the next % (or end of string) + for (;;) { + while (((stbsp__uintptr)f) & 3) { + schk1: + if (f[0] == '%') + goto scandd; + schk2: + if (f[0] == 0) + goto endfmt; + stbsp__chk_cb_buf(1); + *bf++ = f[0]; + ++f; + } + for (;;) { + // Check if the next 4 bytes contain %(0x25) or end of string. + // Using the 'hasless' trick: + // https://graphics.stanford.edu/~seander/bithacks.html#HasLessInWord + stbsp__uint32 v, c; + v = *(stbsp__uint32 *)f; + c = (~v) & 0x80808080; + if (((v ^ 0x25252525) - 0x01010101) & c) + goto schk1; + if ((v - 0x01010101) & c) + goto schk2; + if (callback) + if ((STB_SPRINTF_MIN - (int)(bf - buf)) < 4) + goto schk1; + *(stbsp__uint32 *)bf = v; + bf += 4; + f += 4; + } + } + scandd: + + ++f; + + // ok, we have a percent, read the modifiers first + fw = 0; + pr = -1; + fl = 0; + tz = 0; + + // flags + for (;;) { + switch (f[0]) { + // if we have left justify + case '-': + fl |= STBSP__LEFTJUST; + ++f; + continue; + // if we have leading plus + case '+': + fl |= STBSP__LEADINGPLUS; + ++f; + continue; + // if we have leading space + case ' ': + fl |= STBSP__LEADINGSPACE; + ++f; + continue; + // if we have leading 0x + case '#': + fl |= STBSP__LEADING_0X; + ++f; + continue; + // if we have thousand commas + case '\'': + fl |= STBSP__TRIPLET_COMMA; + ++f; + continue; + // if we have kilo marker (none->kilo->kibi->jedec) + case '$': + if (fl & STBSP__METRIC_SUFFIX) { + if (fl & STBSP__METRIC_1024) { + fl |= STBSP__METRIC_JEDEC; + } else { + fl |= STBSP__METRIC_1024; + } + } else { + fl |= STBSP__METRIC_SUFFIX; + } + ++f; + continue; + // if we don't want space between metric suffix and number + case '_': + fl |= STBSP__METRIC_NOSPACE; + ++f; + continue; + // if we have leading zero + case '0': + fl |= STBSP__LEADINGZERO; + ++f; + goto flags_done; + default: goto flags_done; + } + } + flags_done: + + // get the field width + if (f[0] == '*') { + fw = va_arg(va, stbsp__uint32); + ++f; + } else { + while ((f[0] >= '0') && (f[0] <= '9')) { + fw = fw * 10 + f[0] - '0'; + f++; + } + } + // get the precision + if (f[0] == '.') { + ++f; + if (f[0] == '*') { + pr = va_arg(va, stbsp__uint32); + ++f; + } else { + pr = 0; + while ((f[0] >= '0') && (f[0] <= '9')) { + pr = pr * 10 + f[0] - '0'; + f++; + } + } + } + + // handle integer size overrides + switch (f[0]) { + // are we halfwidth? + case 'h': + fl |= STBSP__HALFWIDTH; + ++f; + break; + // are we 64-bit (unix style) + case 'l': + ++f; + if (f[0] == 'l') { + fl |= STBSP__INTMAX; + ++f; + } + break; + // are we 64-bit on intmax? (c99) + case 'j': + fl |= STBSP__INTMAX; + ++f; + break; + // are we 64-bit on size_t or ptrdiff_t? (c99) + case 'z': + case 't': + fl |= ((sizeof(char *) == 8) ? STBSP__INTMAX : 0); + ++f; + break; + // are we 64-bit (msft style) + case 'I': + if ((f[1] == '6') && (f[2] == '4')) { + fl |= STBSP__INTMAX; + f += 3; + } else if ((f[1] == '3') && (f[2] == '2')) { + f += 3; + } else { + fl |= ((sizeof(void *) == 8) ? STBSP__INTMAX : 0); + ++f; + } + break; + default: break; + } + + // handle each replacement + switch (f[0]) { + #define STBSP__NUMSZ 512 // big enough for e308 (with commas) or e-307 + char num[STBSP__NUMSZ]; + char lead[8]; + char tail[8]; + char *s; + char const *h; + stbsp__uint32 l, n, cs; + stbsp__uint64 n64; +#ifndef STB_SPRINTF_NOFLOAT + double fv; +#endif + stbsp__int32 dp; + char const *sn; + + case 's': + // get the string + s = va_arg(va, char *); + if (s == 0) + s = (char *)"null"; + // get the length + sn = s; + for (;;) { + if ((((stbsp__uintptr)sn) & 3) == 0) + break; + lchk: + if (sn[0] == 0) + goto ld; + ++sn; + } + n = 0xffffffff; + if (pr >= 0) { + n = (stbsp__uint32)(sn - s); + if (n >= (stbsp__uint32)pr) + goto ld; + n = ((stbsp__uint32)(pr - n)) >> 2; + } + while (n) { + stbsp__uint32 v = *(stbsp__uint32 *)sn; + if ((v - 0x01010101) & (~v) & 0x80808080UL) + goto lchk; + sn += 4; + --n; + } + goto lchk; + ld: + + l = (stbsp__uint32)(sn - s); + // clamp to precision + if (l > (stbsp__uint32)pr) + l = pr; + lead[0] = 0; + tail[0] = 0; + pr = 0; + dp = 0; + cs = 0; + // copy the string in + goto scopy; + + case 'c': // char + // get the character + s = num + STBSP__NUMSZ - 1; + *s = (char)va_arg(va, int); + l = 1; + lead[0] = 0; + tail[0] = 0; + pr = 0; + dp = 0; + cs = 0; + goto scopy; + + case 'n': // weird write-bytes specifier + { + int *d = va_arg(va, int *); + *d = tlen + (int)(bf - buf); + } break; + +#ifdef STB_SPRINTF_NOFLOAT + case 'A': // float + case 'a': // hex float + case 'G': // float + case 'g': // float + case 'E': // float + case 'e': // float + case 'f': // float + va_arg(va, double); // eat it + s = (char *)"No float"; + l = 8; + lead[0] = 0; + tail[0] = 0; + pr = 0; + dp = 0; + cs = 0; + goto scopy; +#else + case 'A': // hex float + case 'a': // hex float + h = (f[0] == 'A') ? hexu : hex; + fv = va_arg(va, double); + if (pr == -1) + pr = 6; // default is 6 + // read the double into a string + if (stbsp__real_to_parts((stbsp__int64 *)&n64, &dp, fv)) + fl |= STBSP__NEGATIVE; + + s = num + 64; + + stbsp__lead_sign(fl, lead); + + if (dp == -1023) + dp = (n64) ? -1022 : 0; + else + n64 |= (((stbsp__uint64)1) << 52); + n64 <<= (64 - 56); + if (pr < 15) + n64 += ((((stbsp__uint64)8) << 56) >> (pr * 4)); +// add leading chars + +#ifdef STB_SPRINTF_MSVC_MODE + *s++ = '0'; + *s++ = 'x'; +#else + lead[1 + lead[0]] = '0'; + lead[2 + lead[0]] = 'x'; + lead[0] += 2; +#endif + *s++ = h[(n64 >> 60) & 15]; + n64 <<= 4; + if (pr) + *s++ = stbsp__period; + sn = s; + + // print the bits + n = pr; + if (n > 13) + n = 13; + if (pr > (stbsp__int32)n) + tz = pr - n; + pr = 0; + while (n--) { + *s++ = h[(n64 >> 60) & 15]; + n64 <<= 4; + } + + // print the expo + tail[1] = h[17]; + if (dp < 0) { + tail[2] = '-'; + dp = -dp; + } else + tail[2] = '+'; + n = (dp >= 1000) ? 6 : ((dp >= 100) ? 5 : ((dp >= 10) ? 4 : 3)); + tail[0] = (char)n; + for (;;) { + tail[n] = '0' + dp % 10; + if (n <= 3) + break; + --n; + dp /= 10; + } + + dp = (int)(s - sn); + l = (int)(s - (num + 64)); + s = num + 64; + cs = 1 + (3 << 24); + goto scopy; + + case 'G': // float + case 'g': // float + h = (f[0] == 'G') ? hexu : hex; + fv = va_arg(va, double); + if (pr == -1) + pr = 6; + else if (pr == 0) + pr = 1; // default is 6 + // read the double into a string + if (stbsp__real_to_str(&sn, &l, num, &dp, fv, (pr - 1) | 0x80000000)) + fl |= STBSP__NEGATIVE; + + // clamp the precision and delete extra zeros after clamp + n = pr; + if (l > (stbsp__uint32)pr) + l = pr; + while ((l > 1) && (pr) && (sn[l - 1] == '0')) { + --pr; + --l; + } + + // should we use %e + if ((dp <= -4) || (dp > (stbsp__int32)n)) { + if (pr > (stbsp__int32)l) + pr = l - 1; + else if (pr) + --pr; // when using %e, there is one digit before the decimal + goto doexpfromg; + } + // this is the insane action to get the pr to match %g sematics for %f + if (dp > 0) { + pr = (dp < (stbsp__int32)l) ? l - dp : 0; + } else { + pr = -dp + ((pr > (stbsp__int32)l) ? l : pr); + } + goto dofloatfromg; + + case 'E': // float + case 'e': // float + h = (f[0] == 'E') ? hexu : hex; + fv = va_arg(va, double); + if (pr == -1) + pr = 6; // default is 6 + // read the double into a string + if (stbsp__real_to_str(&sn, &l, num, &dp, fv, pr | 0x80000000)) + fl |= STBSP__NEGATIVE; + doexpfromg: + tail[0] = 0; + stbsp__lead_sign(fl, lead); + if (dp == STBSP__SPECIAL) { + s = (char *)sn; + cs = 0; + pr = 0; + goto scopy; + } + s = num + 64; + // handle leading chars + *s++ = sn[0]; + + if (pr) + *s++ = stbsp__period; + + // handle after decimal + if ((l - 1) > (stbsp__uint32)pr) + l = pr + 1; + for (n = 1; n < l; n++) + *s++ = sn[n]; + // trailing zeros + tz = pr - (l - 1); + pr = 0; + // dump expo + tail[1] = h[0xe]; + dp -= 1; + if (dp < 0) { + tail[2] = '-'; + dp = -dp; + } else + tail[2] = '+'; +#ifdef STB_SPRINTF_MSVC_MODE + n = 5; +#else + n = (dp >= 100) ? 5 : 4; +#endif + tail[0] = (char)n; + for (;;) { + tail[n] = '0' + dp % 10; + if (n <= 3) + break; + --n; + dp /= 10; + } + cs = 1 + (3 << 24); // how many tens + goto flt_lead; + + case 'f': // float + fv = va_arg(va, double); + doafloat: + // do kilos + if (fl & STBSP__METRIC_SUFFIX) { + double divisor; + divisor = 1000.0f; + if (fl & STBSP__METRIC_1024) + divisor = 1024.0; + while (fl < 0x4000000) { + if ((fv < divisor) && (fv > -divisor)) + break; + fv /= divisor; + fl += 0x1000000; + } + } + if (pr == -1) + pr = 6; // default is 6 + // read the double into a string + if (stbsp__real_to_str(&sn, &l, num, &dp, fv, pr)) + fl |= STBSP__NEGATIVE; + dofloatfromg: + tail[0] = 0; + stbsp__lead_sign(fl, lead); + if (dp == STBSP__SPECIAL) { + s = (char *)sn; + cs = 0; + pr = 0; + goto scopy; + } + s = num + 64; + + // handle the three decimal varieties + if (dp <= 0) { + stbsp__int32 i; + // handle 0.000*000xxxx + *s++ = '0'; + if (pr) + *s++ = stbsp__period; + n = -dp; + if ((stbsp__int32)n > pr) + n = pr; + i = n; + while (i) { + if ((((stbsp__uintptr)s) & 3) == 0) + break; + *s++ = '0'; + --i; + } + while (i >= 4) { + *(stbsp__uint32 *)s = 0x30303030; + s += 4; + i -= 4; + } + while (i) { + *s++ = '0'; + --i; + } + if ((stbsp__int32)(l + n) > pr) + l = pr - n; + i = l; + while (i) { + *s++ = *sn++; + --i; + } + tz = pr - (n + l); + cs = 1 + (3 << 24); // how many tens did we write (for commas below) + } else { + cs = (fl & STBSP__TRIPLET_COMMA) ? ((600 - (stbsp__uint32)dp) % 3) : 0; + if ((stbsp__uint32)dp >= l) { + // handle xxxx000*000.0 + n = 0; + for (;;) { + if ((fl & STBSP__TRIPLET_COMMA) && (++cs == 4)) { + cs = 0; + *s++ = stbsp__comma; + } else { + *s++ = sn[n]; + ++n; + if (n >= l) + break; + } + } + if (n < (stbsp__uint32)dp) { + n = dp - n; + if ((fl & STBSP__TRIPLET_COMMA) == 0) { + while (n) { + if ((((stbsp__uintptr)s) & 3) == 0) + break; + *s++ = '0'; + --n; + } + while (n >= 4) { + *(stbsp__uint32 *)s = 0x30303030; + s += 4; + n -= 4; + } + } + while (n) { + if ((fl & STBSP__TRIPLET_COMMA) && (++cs == 4)) { + cs = 0; + *s++ = stbsp__comma; + } else { + *s++ = '0'; + --n; + } + } + } + cs = (int)(s - (num + 64)) + (3 << 24); // cs is how many tens + if (pr) { + *s++ = stbsp__period; + tz = pr; + } + } else { + // handle xxxxx.xxxx000*000 + n = 0; + for (;;) { + if ((fl & STBSP__TRIPLET_COMMA) && (++cs == 4)) { + cs = 0; + *s++ = stbsp__comma; + } else { + *s++ = sn[n]; + ++n; + if (n >= (stbsp__uint32)dp) + break; + } + } + cs = (int)(s - (num + 64)) + (3 << 24); // cs is how many tens + if (pr) + *s++ = stbsp__period; + if ((l - dp) > (stbsp__uint32)pr) + l = pr + dp; + while (n < l) { + *s++ = sn[n]; + ++n; + } + tz = pr - (l - dp); + } + } + pr = 0; + + // handle k,m,g,t + if (fl & STBSP__METRIC_SUFFIX) { + char idx; + idx = 1; + if (fl & STBSP__METRIC_NOSPACE) + idx = 0; + tail[0] = idx; + tail[1] = ' '; + { + if (fl >> 24) { // SI kilo is 'k', JEDEC and SI kibits are 'K'. + if (fl & STBSP__METRIC_1024) + tail[idx + 1] = "_KMGT"[fl >> 24]; + else + tail[idx + 1] = "_kMGT"[fl >> 24]; + idx++; + // If printing kibits and not in jedec, add the 'i'. + if (fl & STBSP__METRIC_1024 && !(fl & STBSP__METRIC_JEDEC)) { + tail[idx + 1] = 'i'; + idx++; + } + tail[0] = idx; + } + } + }; + + flt_lead: + // get the length that we copied + l = (stbsp__uint32)(s - (num + 64)); + s = num + 64; + goto scopy; +#endif + + case 'B': // upper binary + case 'b': // lower binary + h = (f[0] == 'B') ? hexu : hex; + lead[0] = 0; + if (fl & STBSP__LEADING_0X) { + lead[0] = 2; + lead[1] = '0'; + lead[2] = h[0xb]; + } + l = (8 << 4) | (1 << 8); + goto radixnum; + + case 'o': // octal + h = hexu; + lead[0] = 0; + if (fl & STBSP__LEADING_0X) { + lead[0] = 1; + lead[1] = '0'; + } + l = (3 << 4) | (3 << 8); + goto radixnum; + + case 'p': // pointer + fl |= (sizeof(void *) == 8) ? STBSP__INTMAX : 0; + pr = sizeof(void *) * 2; + fl &= ~STBSP__LEADINGZERO; // 'p' only prints the pointer with zeros + // drop through to X + + case 'X': // upper hex + case 'x': // lower hex + h = (f[0] == 'X') ? hexu : hex; + l = (4 << 4) | (4 << 8); + lead[0] = 0; + if (fl & STBSP__LEADING_0X) { + lead[0] = 2; + lead[1] = '0'; + lead[2] = h[16]; + } + radixnum: + // get the number + if (fl & STBSP__INTMAX) + n64 = va_arg(va, stbsp__uint64); + else + n64 = va_arg(va, stbsp__uint32); + + s = num + STBSP__NUMSZ; + dp = 0; + // clear tail, and clear leading if value is zero + tail[0] = 0; + if (n64 == 0) { + lead[0] = 0; + if (pr == 0) { + l = 0; + cs = (((l >> 4) & 15)) << 24; + goto scopy; + } + } + // convert to string + for (;;) { + *--s = h[n64 & ((1 << (l >> 8)) - 1)]; + n64 >>= (l >> 8); + if (!((n64) || ((stbsp__int32)((num + STBSP__NUMSZ) - s) < pr))) + break; + if (fl & STBSP__TRIPLET_COMMA) { + ++l; + if ((l & 15) == ((l >> 4) & 15)) { + l &= ~15; + *--s = stbsp__comma; + } + } + }; + // get the tens and the comma pos + cs = (stbsp__uint32)((num + STBSP__NUMSZ) - s) + ((((l >> 4) & 15)) << 24); + // get the length that we copied + l = (stbsp__uint32)((num + STBSP__NUMSZ) - s); + // copy it + goto scopy; + + case 'u': // unsigned + case 'i': + case 'd': // integer + // get the integer and abs it + if (fl & STBSP__INTMAX) { + stbsp__int64 i64 = va_arg(va, stbsp__int64); + n64 = (stbsp__uint64)i64; + if ((f[0] != 'u') && (i64 < 0)) { + n64 = (stbsp__uint64)-i64; + fl |= STBSP__NEGATIVE; + } + } else { + stbsp__int32 i = va_arg(va, stbsp__int32); + n64 = (stbsp__uint32)i; + if ((f[0] != 'u') && (i < 0)) { + n64 = (stbsp__uint32)-i; + fl |= STBSP__NEGATIVE; + } + } + +#ifndef STB_SPRINTF_NOFLOAT + if (fl & STBSP__METRIC_SUFFIX) { + if (n64 < 1024) + pr = 0; + else if (pr == -1) + pr = 1; + fv = (double)(stbsp__int64)n64; + goto doafloat; + } +#endif + + // convert to string + s = num + STBSP__NUMSZ; + l = 0; + + for (;;) { + // do in 32-bit chunks (avoid lots of 64-bit divides even with constant denominators) + char *o = s - 8; + if (n64 >= 100000000) { + n = (stbsp__uint32)(n64 % 100000000); + n64 /= 100000000; + } else { + n = (stbsp__uint32)n64; + n64 = 0; + } + if ((fl & STBSP__TRIPLET_COMMA) == 0) { + while (n) { + s -= 2; + *(stbsp__uint16 *)s = *(stbsp__uint16 *)&stbsp__digitpair[(n % 100) * 2]; + n /= 100; + } + } + while (n) { + if ((fl & STBSP__TRIPLET_COMMA) && (l++ == 3)) { + l = 0; + *--s = stbsp__comma; + --o; + } else { + *--s = (char)(n % 10) + '0'; + n /= 10; + } + } + if (n64 == 0) { + if ((s[0] == '0') && (s != (num + STBSP__NUMSZ))) + ++s; + break; + } + while (s != o) + if ((fl & STBSP__TRIPLET_COMMA) && (l++ == 3)) { + l = 0; + *--s = stbsp__comma; + --o; + } else { + *--s = '0'; + } + } + + tail[0] = 0; + stbsp__lead_sign(fl, lead); + + // get the length that we copied + l = (stbsp__uint32)((num + STBSP__NUMSZ) - s); + if (l == 0) { + *--s = '0'; + l = 1; + } + cs = l + (3 << 24); + if (pr < 0) + pr = 0; + + scopy: + // get fw=leading/trailing space, pr=leading zeros + if (pr < (stbsp__int32)l) + pr = l; + n = pr + lead[0] + tail[0] + tz; + if (fw < (stbsp__int32)n) + fw = n; + fw -= n; + pr -= l; + + // handle right justify and leading zeros + if ((fl & STBSP__LEFTJUST) == 0) { + if (fl & STBSP__LEADINGZERO) // if leading zeros, everything is in pr + { + pr = (fw > pr) ? fw : pr; + fw = 0; + } else { + fl &= ~STBSP__TRIPLET_COMMA; // if no leading zeros, then no commas + } + } + + // copy the spaces and/or zeros + if (fw + pr) { + stbsp__int32 i; + stbsp__uint32 c; + + // copy leading spaces (or when doing %8.4d stuff) + if ((fl & STBSP__LEFTJUST) == 0) + while (fw > 0) { + stbsp__cb_buf_clamp(i, fw); + fw -= i; + while (i) { + if ((((stbsp__uintptr)bf) & 3) == 0) + break; + *bf++ = ' '; + --i; + } + while (i >= 4) { + *(stbsp__uint32 *)bf = 0x20202020; + bf += 4; + i -= 4; + } + while (i) { + *bf++ = ' '; + --i; + } + stbsp__chk_cb_buf(1); + } + + // copy leader + sn = lead + 1; + while (lead[0]) { + stbsp__cb_buf_clamp(i, lead[0]); + lead[0] -= (char)i; + while (i) { + *bf++ = *sn++; + --i; + } + stbsp__chk_cb_buf(1); + } + + // copy leading zeros + c = cs >> 24; + cs &= 0xffffff; + cs = (fl & STBSP__TRIPLET_COMMA) ? ((stbsp__uint32)(c - ((pr + cs) % (c + 1)))) : 0; + while (pr > 0) { + stbsp__cb_buf_clamp(i, pr); + pr -= i; + if ((fl & STBSP__TRIPLET_COMMA) == 0) { + while (i) { + if ((((stbsp__uintptr)bf) & 3) == 0) + break; + *bf++ = '0'; + --i; + } + while (i >= 4) { + *(stbsp__uint32 *)bf = 0x30303030; + bf += 4; + i -= 4; + } + } + while (i) { + if ((fl & STBSP__TRIPLET_COMMA) && (cs++ == c)) { + cs = 0; + *bf++ = stbsp__comma; + } else + *bf++ = '0'; + --i; + } + stbsp__chk_cb_buf(1); + } + } + + // copy leader if there is still one + sn = lead + 1; + while (lead[0]) { + stbsp__int32 i; + stbsp__cb_buf_clamp(i, lead[0]); + lead[0] -= (char)i; + while (i) { + *bf++ = *sn++; + --i; + } + stbsp__chk_cb_buf(1); + } + + // copy the string + n = l; + while (n) { + stbsp__int32 i; + stbsp__cb_buf_clamp(i, n); + n -= i; + STBSP__UNALIGNED(while (i >= 4) { + *(stbsp__uint32 *)bf = *(stbsp__uint32 *)s; + bf += 4; + s += 4; + i -= 4; + }) + while (i) { + *bf++ = *s++; + --i; + } + stbsp__chk_cb_buf(1); + } + + // copy trailing zeros + while (tz) { + stbsp__int32 i; + stbsp__cb_buf_clamp(i, tz); + tz -= i; + while (i) { + if ((((stbsp__uintptr)bf) & 3) == 0) + break; + *bf++ = '0'; + --i; + } + while (i >= 4) { + *(stbsp__uint32 *)bf = 0x30303030; + bf += 4; + i -= 4; + } + while (i) { + *bf++ = '0'; + --i; + } + stbsp__chk_cb_buf(1); + } + + // copy tail if there is one + sn = tail + 1; + while (tail[0]) { + stbsp__int32 i; + stbsp__cb_buf_clamp(i, tail[0]); + tail[0] -= (char)i; + while (i) { + *bf++ = *sn++; + --i; + } + stbsp__chk_cb_buf(1); + } + + // handle the left justify + if (fl & STBSP__LEFTJUST) + if (fw > 0) { + while (fw) { + stbsp__int32 i; + stbsp__cb_buf_clamp(i, fw); + fw -= i; + while (i) { + if ((((stbsp__uintptr)bf) & 3) == 0) + break; + *bf++ = ' '; + --i; + } + while (i >= 4) { + *(stbsp__uint32 *)bf = 0x20202020; + bf += 4; + i -= 4; + } + while (i--) + *bf++ = ' '; + stbsp__chk_cb_buf(1); + } + } + break; + + default: // unknown, just copy code + s = num + STBSP__NUMSZ - 1; + *s = f[0]; + l = 1; + fw = pr = fl = 0; + lead[0] = 0; + tail[0] = 0; + pr = 0; + dp = 0; + cs = 0; + goto scopy; + } + ++f; + } +endfmt: + + if (!callback) + *bf = 0; + else + stbsp__flush_cb(); + +done: + return tlen + (int)(bf - buf); +} + +// cleanup +#undef STBSP__LEFTJUST +#undef STBSP__LEADINGPLUS +#undef STBSP__LEADINGSPACE +#undef STBSP__LEADING_0X +#undef STBSP__LEADINGZERO +#undef STBSP__INTMAX +#undef STBSP__TRIPLET_COMMA +#undef STBSP__NEGATIVE +#undef STBSP__METRIC_SUFFIX +#undef STBSP__NUMSZ +#undef stbsp__chk_cb_bufL +#undef stbsp__chk_cb_buf +#undef stbsp__flush_cb +#undef stbsp__cb_buf_clamp + +// ============================================================================ +// wrapper functions + +STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(sprintf)(char *buf, char const *fmt, ...) +{ + int result; + va_list va; + va_start(va, fmt); + result = STB_SPRINTF_DECORATE(vsprintfcb)(0, 0, buf, fmt, va); + va_end(va); + return result; +} + +typedef struct stbsp__context { + char *buf; + int count; + char tmp[STB_SPRINTF_MIN]; +} stbsp__context; + +static char *stbsp__clamp_callback(char *buf, void *user, int len) +{ + stbsp__context *c = (stbsp__context *)user; + + if (len > c->count) + len = c->count; + + if (len) { + if (buf != c->buf) { + char *s, *d, *se; + d = c->buf; + s = buf; + se = buf + len; + do { + *d++ = *s++; + } while (s < se); + } + c->buf += len; + c->count -= len; + } + + if (c->count <= 0) + return 0; + return (c->count >= STB_SPRINTF_MIN) ? c->buf : c->tmp; // go direct into buffer if you can +} + +STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(vsnprintf)(char *buf, int count, char const *fmt, va_list va) +{ + stbsp__context c; + int l; + + if (count == 0) + return 0; + + c.buf = buf; + c.count = count; + + STB_SPRINTF_DECORATE(vsprintfcb)(stbsp__clamp_callback, &c, stbsp__clamp_callback(0, &c, 0), fmt, va); + + // zero-terminate + l = (int)(c.buf - buf); + if (l >= count) // should never be greater, only equal (or less) than count + l = count - 1; + buf[l] = 0; + + return l; +} + +STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(snprintf)(char *buf, int count, char const *fmt, ...) +{ + int result; + va_list va; + va_start(va, fmt); + + result = STB_SPRINTF_DECORATE(vsnprintf)(buf, count, fmt, va); + va_end(va); + + return result; +} + +STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(vsprintf)(char *buf, char const *fmt, va_list va) +{ + return STB_SPRINTF_DECORATE(vsprintfcb)(0, 0, buf, fmt, va); +} + +// ======================================================================= +// low level float utility functions + +#ifndef STB_SPRINTF_NOFLOAT + +// copies d to bits w/ strict aliasing (this compiles to nothing on /Ox) +#define STBSP__COPYFP(dest, src) \ + { \ + int cn; \ + for (cn = 0; cn < 8; cn++) \ + ((char *)&dest)[cn] = ((char *)&src)[cn]; \ + } + +// get float info +static stbsp__int32 stbsp__real_to_parts(stbsp__int64 *bits, stbsp__int32 *expo, double value) +{ + double d; + stbsp__int64 b = 0; + + // load value and round at the frac_digits + d = value; + + STBSP__COPYFP(b, d); + + *bits = b & ((((stbsp__uint64)1) << 52) - 1); + *expo = (stbsp__int32)(((b >> 52) & 2047) - 1023); + + return (stbsp__int32)(b >> 63); +} + +static double const stbsp__bot[23] = { + 1e+000, 1e+001, 1e+002, 1e+003, 1e+004, 1e+005, 1e+006, 1e+007, 1e+008, 1e+009, 1e+010, 1e+011, + 1e+012, 1e+013, 1e+014, 1e+015, 1e+016, 1e+017, 1e+018, 1e+019, 1e+020, 1e+021, 1e+022 +}; +static double const stbsp__negbot[22] = { + 1e-001, 1e-002, 1e-003, 1e-004, 1e-005, 1e-006, 1e-007, 1e-008, 1e-009, 1e-010, 1e-011, + 1e-012, 1e-013, 1e-014, 1e-015, 1e-016, 1e-017, 1e-018, 1e-019, 1e-020, 1e-021, 1e-022 +}; +static double const stbsp__negboterr[22] = { + -5.551115123125783e-018, -2.0816681711721684e-019, -2.0816681711721686e-020, -4.7921736023859299e-021, -8.1803053914031305e-022, 4.5251888174113741e-023, + 4.5251888174113739e-024, -2.0922560830128471e-025, -6.2281591457779853e-026, -3.6432197315497743e-027, 6.0503030718060191e-028, 2.0113352370744385e-029, + -3.0373745563400371e-030, 1.1806906454401013e-032, -7.7705399876661076e-032, 2.0902213275965398e-033, -7.1542424054621921e-034, -7.1542424054621926e-035, + 2.4754073164739869e-036, 5.4846728545790429e-037, 9.2462547772103625e-038, -4.8596774326570872e-039 +}; +static double const stbsp__top[13] = { + 1e+023, 1e+046, 1e+069, 1e+092, 1e+115, 1e+138, 1e+161, 1e+184, 1e+207, 1e+230, 1e+253, 1e+276, 1e+299 +}; +static double const stbsp__negtop[13] = { + 1e-023, 1e-046, 1e-069, 1e-092, 1e-115, 1e-138, 1e-161, 1e-184, 1e-207, 1e-230, 1e-253, 1e-276, 1e-299 +}; +static double const stbsp__toperr[13] = { + 8388608, + 6.8601809640529717e+028, + -7.253143638152921e+052, + -4.3377296974619174e+075, + -1.5559416129466825e+098, + -3.2841562489204913e+121, + -3.7745893248228135e+144, + -1.7356668416969134e+167, + -3.8893577551088374e+190, + -9.9566444326005119e+213, + 6.3641293062232429e+236, + -5.2069140800249813e+259, + -5.2504760255204387e+282 +}; +static double const stbsp__negtoperr[13] = { + 3.9565301985100693e-040, -2.299904345391321e-063, 3.6506201437945798e-086, 1.1875228833981544e-109, + -5.0644902316928607e-132, -6.7156837247865426e-155, -2.812077463003139e-178, -5.7778912386589953e-201, + 7.4997100559334532e-224, -4.6439668915134491e-247, -6.3691100762962136e-270, -9.436808465446358e-293, + 8.0970921678014997e-317 +}; + +#if defined(_MSC_VER) && (_MSC_VER <= 1200) +static stbsp__uint64 const stbsp__powten[20] = { + 1, + 10, + 100, + 1000, + 10000, + 100000, + 1000000, + 10000000, + 100000000, + 1000000000, + 10000000000, + 100000000000, + 1000000000000, + 10000000000000, + 100000000000000, + 1000000000000000, + 10000000000000000, + 100000000000000000, + 1000000000000000000, + 10000000000000000000U +}; +#define stbsp__tento19th ((stbsp__uint64)1000000000000000000) +#else +static stbsp__uint64 const stbsp__powten[20] = { + 1, + 10, + 100, + 1000, + 10000, + 100000, + 1000000, + 10000000, + 100000000, + 1000000000, + 10000000000ULL, + 100000000000ULL, + 1000000000000ULL, + 10000000000000ULL, + 100000000000000ULL, + 1000000000000000ULL, + 10000000000000000ULL, + 100000000000000000ULL, + 1000000000000000000ULL, + 10000000000000000000ULL +}; +#define stbsp__tento19th (1000000000000000000ULL) +#endif + +#define stbsp__ddmulthi(oh, ol, xh, yh) \ + { \ + double ahi = 0, alo, bhi = 0, blo; \ + stbsp__int64 bt; \ + oh = xh * yh; \ + STBSP__COPYFP(bt, xh); \ + bt &= ((~(stbsp__uint64)0) << 27); \ + STBSP__COPYFP(ahi, bt); \ + alo = xh - ahi; \ + STBSP__COPYFP(bt, yh); \ + bt &= ((~(stbsp__uint64)0) << 27); \ + STBSP__COPYFP(bhi, bt); \ + blo = yh - bhi; \ + ol = ((ahi * bhi - oh) + ahi * blo + alo * bhi) + alo * blo; \ + } + +#define stbsp__ddtoS64(ob, xh, xl) \ + { \ + double ahi = 0, alo, vh, t; \ + ob = (stbsp__int64)ph; \ + vh = (double)ob; \ + ahi = (xh - vh); \ + t = (ahi - xh); \ + alo = (xh - (ahi - t)) - (vh + t); \ + ob += (stbsp__int64)(ahi + alo + xl); \ + } + +#define stbsp__ddrenorm(oh, ol) \ + { \ + double s; \ + s = oh + ol; \ + ol = ol - (s - oh); \ + oh = s; \ + } + +#define stbsp__ddmultlo(oh, ol, xh, xl, yh, yl) ol = ol + (xh * yl + xl * yh); + +#define stbsp__ddmultlos(oh, ol, xh, yl) ol = ol + (xh * yl); + +static void stbsp__raise_to_power10(double *ohi, double *olo, double d, stbsp__int32 power) // power can be -323 to +350 +{ + double ph, pl; + if ((power >= 0) && (power <= 22)) { + stbsp__ddmulthi(ph, pl, d, stbsp__bot[power]); + } else { + stbsp__int32 e, et, eb; + double p2h, p2l; + + e = power; + if (power < 0) + e = -e; + et = (e * 0x2c9) >> 14; /* %23 */ + if (et > 13) + et = 13; + eb = e - (et * 23); + + ph = d; + pl = 0.0; + if (power < 0) { + if (eb) { + --eb; + stbsp__ddmulthi(ph, pl, d, stbsp__negbot[eb]); + stbsp__ddmultlos(ph, pl, d, stbsp__negboterr[eb]); + } + if (et) { + stbsp__ddrenorm(ph, pl); + --et; + stbsp__ddmulthi(p2h, p2l, ph, stbsp__negtop[et]); + stbsp__ddmultlo(p2h, p2l, ph, pl, stbsp__negtop[et], stbsp__negtoperr[et]); + ph = p2h; + pl = p2l; + } + } else { + if (eb) { + e = eb; + if (eb > 22) + eb = 22; + e -= eb; + stbsp__ddmulthi(ph, pl, d, stbsp__bot[eb]); + if (e) { + stbsp__ddrenorm(ph, pl); + stbsp__ddmulthi(p2h, p2l, ph, stbsp__bot[e]); + stbsp__ddmultlos(p2h, p2l, stbsp__bot[e], pl); + ph = p2h; + pl = p2l; + } + } + if (et) { + stbsp__ddrenorm(ph, pl); + --et; + stbsp__ddmulthi(p2h, p2l, ph, stbsp__top[et]); + stbsp__ddmultlo(p2h, p2l, ph, pl, stbsp__top[et], stbsp__toperr[et]); + ph = p2h; + pl = p2l; + } + } + } + stbsp__ddrenorm(ph, pl); + *ohi = ph; + *olo = pl; +} + +// given a float value, returns the significant bits in bits, and the position of the +// decimal point in decimal_pos. +/-INF and NAN are specified by special values +// returned in the decimal_pos parameter. +// frac_digits is absolute normally, but if you want from first significant digits (got %g and %e), or in 0x80000000 +static stbsp__int32 stbsp__real_to_str(char const **start, stbsp__uint32 *len, char *out, stbsp__int32 *decimal_pos, double value, stbsp__uint32 frac_digits) +{ + double d; + stbsp__int64 bits = 0; + stbsp__int32 expo, e, ng, tens; + + d = value; + STBSP__COPYFP(bits, d); + expo = (stbsp__int32)((bits >> 52) & 2047); + ng = (stbsp__int32)(bits >> 63); + if (ng) + d = -d; + + if (expo == 2047) // is nan or inf? + { + *start = (bits & ((((stbsp__uint64)1) << 52) - 1)) ? "NaN" : "Inf"; + *decimal_pos = STBSP__SPECIAL; + *len = 3; + return ng; + } + + if (expo == 0) // is zero or denormal + { + if ((bits << 1) == 0) // do zero + { + *decimal_pos = 1; + *start = out; + out[0] = '0'; + *len = 1; + return ng; + } + // find the right expo for denormals + { + stbsp__int64 v = ((stbsp__uint64)1) << 51; + while ((bits & v) == 0) { + --expo; + v >>= 1; + } + } + } + + // find the decimal exponent as well as the decimal bits of the value + { + double ph, pl; + + // log10 estimate - very specifically tweaked to hit or undershoot by no more than 1 of log10 of all expos 1..2046 + tens = expo - 1023; + tens = (tens < 0) ? ((tens * 617) / 2048) : (((tens * 1233) / 4096) + 1); + + // move the significant bits into position and stick them into an int + stbsp__raise_to_power10(&ph, &pl, d, 18 - tens); + + // get full as much precision from double-double as possible + stbsp__ddtoS64(bits, ph, pl); + + // check if we undershot + if (((stbsp__uint64)bits) >= stbsp__tento19th) + ++tens; + } + + // now do the rounding in integer land + frac_digits = (frac_digits & 0x80000000) ? ((frac_digits & 0x7ffffff) + 1) : (tens + frac_digits); + if ((frac_digits < 24)) { + stbsp__uint32 dg = 1; + if ((stbsp__uint64)bits >= stbsp__powten[9]) + dg = 10; + while ((stbsp__uint64)bits >= stbsp__powten[dg]) { + ++dg; + if (dg == 20) + goto noround; + } + if (frac_digits < dg) { + stbsp__uint64 r; + // add 0.5 at the right position and round + e = dg - frac_digits; + if ((stbsp__uint32)e >= 24) + goto noround; + r = stbsp__powten[e]; + bits = bits + (r / 2); + if ((stbsp__uint64)bits >= stbsp__powten[dg]) + ++tens; + bits /= r; + } + noround:; + } + + // kill long trailing runs of zeros + if (bits) { + stbsp__uint32 n; + for (;;) { + if (bits <= 0xffffffff) + break; + if (bits % 1000) + goto donez; + bits /= 1000; + } + n = (stbsp__uint32)bits; + while ((n % 1000) == 0) + n /= 1000; + bits = n; + donez:; + } + + // convert to string + out += 64; + e = 0; + for (;;) { + stbsp__uint32 n; + char *o = out - 8; + // do the conversion in chunks of U32s (avoid most 64-bit divides, worth it, constant denomiators be damned) + if (bits >= 100000000) { + n = (stbsp__uint32)(bits % 100000000); + bits /= 100000000; + } else { + n = (stbsp__uint32)bits; + bits = 0; + } + while (n) { + out -= 2; + *(stbsp__uint16 *)out = *(stbsp__uint16 *)&stbsp__digitpair[(n % 100) * 2]; + n /= 100; + e += 2; + } + if (bits == 0) { + if ((e) && (out[0] == '0')) { + ++out; + --e; + } + break; + } + while (out != o) { + *--out = '0'; + ++e; + } + } + + *decimal_pos = tens; + *start = out; + *len = e; + return ng; +} + +#undef stbsp__ddmulthi +#undef stbsp__ddrenorm +#undef stbsp__ddmultlo +#undef stbsp__ddmultlos +#undef STBSP__SPECIAL +#undef STBSP__COPYFP + +#endif // STB_SPRINTF_NOFLOAT + +// clean up +#undef stbsp__uint16 +#undef stbsp__uint32 +#undef stbsp__int32 +#undef stbsp__uint64 +#undef stbsp__int64 +#undef STBSP__UNALIGNED + +#endif // STB_SPRINTF_IMPLEMENTATION + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +------------------------------------------------------------------------------ +*/ diff --git a/test/include/libtransistor/svc.h b/test/include/libtransistor/svc.h new file mode 100644 index 0000000..cb9fcef --- /dev/null +++ b/test/include/libtransistor/svc.h @@ -0,0 +1,122 @@ +#pragma once + +typedef struct PACKED { + void *base_addr; + u64 size; + u32 memory_type; + u32 memory_attribute; + u32 permission; + u32 device_ref_count; + u32 ipc_ref_count; + u32 padding; +} memory_info_t; + +result_t svcSetHeapSize(void **outAddr, u32 size); +result_t svcSetMemoryPermission(void *addr, u64 size, u32 permission); +result_t svcSetMemoryAttribute(void *addr, u64 size, u32 state0, u32 state1); +result_t svcMapMemory(void *dest, void *src, u64 size); +result_t svcUnmapMemory(void *dest, void *src, u64 size); +result_t svcQueryMemory(memory_info_t *memory_info, u32 *page_info, void *addr); +void svcExitProcess(); +result_t svcCreateThread(thread_h *out, thread_entry entry, u64 arg, void *stacktop, s32 priority, s32 processor_id); +result_t svcStartThread(thread_h thread); +void svcExitThread(); +result_t svcSleepThread(u64 nanos); +result_t svcGetThreadPriority(u32 *priority, thread_h thread); +result_t svcSetThreadCoreMask(thread_h thread, u32 in, u64 in2); +u32 svcGetCurrentProcessorNumber(); +result_t svcSignalEvent(handle_t event); +result_t svcClearEvent(handle_t event); +result_t svcMapSharedMemory(shared_memory_h block, void *addr, u64 size, u32 permission); +result_t svcUnmapSharedMemory(shared_memory_h block, void *addr, u64 size); +result_t svcCreateTransferMemory(transfer_memory_h *out, void *addr, u64 size, u32 permission); +result_t svcCloseHandle(handle_t handle); +result_t svcResetSignal(handle_t signal); +result_t svcWaitSynchronization(u32 *handle_index, handle_t *handles, u32 num_handles, u64 timeout); +result_t svcCancelSynchronization(handle_t handle); +void svcArbitrateLock(thread_h current_thread, void *lock, thread_h requesting_thread); +void svcArbitrateUnlock(void *lock); +result_t svcWaitProcessWideKeyAtomic(void *ptr0, void *ptr1, thread_h thread, u64 timeout); +result_t svcSignalProcessWideKey(void *ptr, u32 value); +u64 svcGetSystemTick(); +result_t svcConnectToNamedPort(session_h *out, char name[8]); +// sendSyncRequestLight +result_t svcSendSyncRequest(session_h session); +result_t svcSendSyncRequestWithUserBuffer(void *buffer, u64 size, session_h session); +// sendAsyncRequestWithUserBuffer +// getProcessId +// getThreadId +// break +void svcOutputDebugString(char *str, u64 size); +void svcReturnFromException(u64 result); +result_t svcGetInfo(u64 *info, u64 info_id, handle_t handle, u64 info_sub_id); +// flushEntireDataCache +// flushDataCache +// mapPhysicalMemory +// unmapPhysicalMemory +// 0x2E? +// getLastThreadInfo +// getResourceLimitLimitValue +// getResourceLimitCurrentValue +// setThreadActivity +// getThreadContext3 +// 0x34-0x3B? +// dumpInfo +// 0x3D-0x3F? +// createSession +result_t svcAcceptSession(session_h *out, port_h port); +// replyAndReceiveLight +result_t svcReplyAndReceive(u32 *handle_idx, session_h *handles, u32 num_handles, session_h reply_session, u64 timeout); +result_t svcReplyAndReceiveWithUserBuffer(u32 *handle_idx, void *buffer, u64 size, session_h *handles, u32 num_handles, session_h reply_session, u64 timeout); +// createEvent +// 0x46-0x4E? +// sleepSystem +result_t svcReadWriteRegister(u32 *out_value, u64 addr, u32 rw_mask, u32 in_value); +// setProcessActivity +result_t svcCreateSharedMemory(shared_memory_h *out, u64 size, u32 self_permissions, u32 foreign_permissions); +result_t svcMapTransferMemory(transfer_memory_h handle, void *addr, u64 size, u32 perm); +result_t svcUnmapTransferMemory(transfer_memory_h handle, void *addr, u64 size); +// createInterruptEvent +// queryPhysicalAddress +result_t svcQueryIoMapping(void *virt_addr, u64 phys_addr, u64 size); +// createDeviceAddressSpace +result_t svcAttachDeviceAddressSpace(u32 device, dev_addr_space_h space); +result_t svcDetachDeviceAddressSpace(u32 device, dev_addr_space_h space); +result_t svcMapDeviceAddressSpaceByForce(dev_addr_space_h space, process_h process, u64 dev_addr, u64 dev_size, u64 map_addr, u32 perm); +result_t svcMapDeviceAddressSpaceAligned(dev_addr_space_h space, process_h process, u64 dev_addr, u64 dev_size, u64 map_addr, u32 perm); +// mapDeviceAddressSpace +result_t svcUnmapDeviceAddressSpace(dev_addr_space_h space, process_h process, u64 map_addr, u64 map_size, u32 perm); +// invalidateProcessDataCache +// storeProcessDataCache +// flushProcessDataCache +result_t svcDebugActiveprocess(debug_h *out, u64 process_id); +// breakDebugProcess +// terminateDebugProcess +// getDebugEvent +// continueDebugEvent +// getProcessList +// getThreadList +// getDebugThreadContext +// setDebugThreadContext +result_t svcQueryDebugProcessMemory(memory_info_t *memory_info, u32 *page_info, debug_h debug, u64 addr); +result_t svcReadDebugProcessMemory(void *buffer, debug_h debug, u64 addr, u64 size); +result_t svcWriteDebugProcessMemory(debug_h debug, void *buffer, u64 addr, u64 size); +// setHardwareBreakPoint +// getDebugThreadParam +// 0x6D-0x6F? +// createPort +// manageNamedPort +// connectToPort +// setProcessMemoryPermission +// mapProcessMemory +// unmapProcessMemory +// queryProcessmemory +// mapProcessCodeMemory +// unmapProcessCodeMemory +// createProcess +// startProcess +// terminateProcess +// getProcessInfo +// createResourceLimit +// setResourceLimitLimitValue +// callSecureMonitor diff --git a/test/include/libtransistor/tls.h b/test/include/libtransistor/tls.h new file mode 100644 index 0000000..6857723 --- /dev/null +++ b/test/include/libtransistor/tls.h @@ -0,0 +1,3 @@ +#pragma once + +void *get_tls(); diff --git a/test/include/libtransistor/types.h b/test/include/libtransistor/types.h new file mode 100644 index 0000000..0587437 --- /dev/null +++ b/test/include/libtransistor/types.h @@ -0,0 +1,73 @@ +/** + * @file types.h + * @brief Various system types. + */ + +// Based on ctrulib's types.h + +#pragma once + +#include +#include +#include + +/// The maximum value of a u64. +#define U64_MAX UINT64_MAX + +/// would be nice if newlib had this already +#ifndef SSIZE_MAX +#ifdef SIZE_MAX +#define SSIZE_MAX ((SIZE_MAX) >> 1) +#endif +#endif + +typedef uint8_t u8; ///< 8-bit unsigned integer +typedef uint16_t u16; ///< 16-bit unsigned integer +typedef uint32_t u32; ///< 32-bit unsigned integer +typedef uint64_t u64; ///< 64-bit unsigned integer + +typedef int8_t s8; ///< 8-bit signed integer +typedef int16_t s16; ///< 16-bit signed integer +typedef int32_t s32; ///< 32-bit signed integer +typedef int64_t s64; ///< 64-bit signed integer + +typedef volatile u8 vu8; ///< 8-bit volatile unsigned integer. +typedef volatile u16 vu16; ///< 16-bit volatile unsigned integer. +typedef volatile u32 vu32; ///< 32-bit volatile unsigned integer. +typedef volatile u64 vu64; ///< 64-bit volatile unsigned integer. + +typedef volatile s8 vs8; ///< 8-bit volatile signed integer. +typedef volatile s16 vs16; ///< 16-bit volatile signed integer. +typedef volatile s32 vs32; ///< 32-bit volatile signed integer. +typedef volatile s64 vs64; ///< 64-bit volatile signed integer. + +typedef u32 handle_t; ///< Resource handle. +typedef handle_t thread_h; +typedef handle_t shared_memory_h; +typedef handle_t transfer_memory_h; +typedef handle_t session_h; +typedef handle_t port_h; +typedef handle_t dev_addr_space_h; +typedef handle_t process_h; +typedef handle_t debug_h; +typedef u32 result_t; ///< Function result. +typedef void (*thread_entry)(void *); ///< Thread entrypoint function. +typedef void (*voidfn)(void); + +/// Creates a bitmask from a bit number. +#define BIT(n) (1U<<(n)) + +/// Aligns a struct (and other types?) to m, making sure that the size of the struct is a multiple of m. +#define ALIGN(m) __attribute__((aligned(m))) +/// Packs a struct (and other types?) so it won't include padding bytes. +#define PACKED __attribute__((packed)) + +#ifndef LIBTRANSISTOR +/// Flags a function as deprecated. +#define DEPRECATED __attribute__ ((deprecated)) +#else +/// Flags a function as deprecated. +#define DEPRECATED +#endif + +#define RESULT_OK 0 diff --git a/test/include/libtransistor/util.h b/test/include/libtransistor/util.h new file mode 100644 index 0000000..1af5e95 --- /dev/null +++ b/test/include/libtransistor/util.h @@ -0,0 +1,15 @@ +#pragma once + +char nybble2hex(u8 nybble); +void hexdump(void *rawbuf, size_t size); +void hexnum(int num); +int log_string(char *string, size_t len); + +#define STB_SPRINTF_DECORATE(name) dbg_##name +#include "stb_sprintf.h" + +#include + +int dbg_printf(char const *fmt, ...); +int dbg_vprintf(char const *fmt, va_list va); + diff --git a/test/lib/crt0.nro.S b/test/lib/crt0.nro.S new file mode 100644 index 0000000..3a43552 --- /dev/null +++ b/test/lib/crt0.nro.S @@ -0,0 +1,58 @@ +.hidden NORELOC__filestart +.global NORELOC__nro_modhdr +.hidden NORELOC__nro_modhdr + +.hidden NORELOC_TEXT_START_ +.hidden NORELOC_TEXT_END_ +.hidden NORELOC_RODATA_START_ +.hidden NORELOC_DYNSTR_START_ +.hidden NORELOC_DYNSYM_START_ +.hidden NORELOC_RODATA_END_ +.hidden NORELOC_DATA_START_ +.hidden NORELOC_DYNAMIC_START_ +.hidden NORELOC_GOT_START_ +.hidden NORELOC_GOT_PLT_START_ +.hidden NORELOC_DATA_END_ +.hidden NORELOC_BSS_START_ +.hidden NORELOC_BSS_END_ + +.section .text, "e" +NORELOC__filestart: +.global _start +_start: + .fill 0x80, 1, 0 + +.section .data, "e" + .word 0, 8 +NORELOC__nro_modhdr: + .ascii "MOD0" + .word NORELOC_DYNAMIC_START_ - NORELOC__nro_modhdr + .word NORELOC_BSS_START_ - NORELOC__nro_modhdr + .word NORELOC_BSS_END_ - NORELOC__nro_modhdr + .word 0, 0 // eh_frame_hdr start/end + .word 0 // runtime-generated module object offset + .quad log_buffer + .quad log_length + +.section .text, "e" +.global start +start: + sub sp, sp, 0x10 + stp x29, x30, [sp] + //ldr x1, __crt0_exit_frame + //stp x29, x30, [x1] + bl main + ldp x29, x30, [sp], 0x10 + ret + +.global _exit +_exit: + //ldr x1, __crt0_exit_frame + //ldp x29, x30, [x1] + //ret + b _exit + +.section .bss +__crt0_exit_frame: + .quad 0 + .quad 0 diff --git a/test/lib/crt0.nso.S b/test/lib/crt0.nso.S new file mode 100644 index 0000000..2f46779 --- /dev/null +++ b/test/lib/crt0.nso.S @@ -0,0 +1,42 @@ +.hidden NORELOC__filestart +.global NORELOC__nro_modhdr +.hidden NORELOC__nro_modhdr + +.hidden NORELOC_TEXT_START_ +.hidden NORELOC_TEXT_END_ +.hidden NORELOC_RODATA_START_ +.hidden NORELOC_DYNSTR_START_ +.hidden NORELOC_DYNSYM_START_ +.hidden NORELOC_RODATA_END_ +.hidden NORELOC_DATA_START_ +.hidden NORELOC_DYNAMIC_START_ +.hidden NORELOC_GOT_START_ +.hidden NORELOC_GOT_PLT_START_ +.hidden NORELOC_DATA_END_ +.hidden NORELOC_BSS_START_ +.hidden NORELOC_BSS_END_ + +.section .text, "e" +NORELOC__filestart: +.global _start +_start: + b start + .word NORELOC__nro_modhdr - NORELOC__filestart + +.section .data, "e" + .word 0, 8 +NORELOC__nro_modhdr: + .ascii "MOD0" + .word NORELOC_DYNAMIC_START_ - NORELOC__nro_modhdr + .word NORELOC_BSS_START_ - NORELOC__nro_modhdr + .word NORELOC_BSS_END_ - NORELOC__nro_modhdr + .word 0, 0 // eh_frame_hdr start/end + .word 0 // runtime-generated module object offset + +.section .text, "e" +start: + bl main +loop: +.global _exit +_exit: + b loop diff --git a/test/lib/ipc.c b/test/lib/ipc.c new file mode 100644 index 0000000..cf8c172 --- /dev/null +++ b/test/lib/ipc.c @@ -0,0 +1,526 @@ +#include +#include +#include +#include +#include + +ipc_buffer_t null_buffer = { + .addr = 0, + .size = 0, + .type = 0 +}; + +ipc_object_t ipc_null_object = { + .session = 0, + .object_id = -1 +}; + +ipc_request_t ipc_default_request = { + .type = 4, + .num_buffers = 0, + .buffers = NULL, + .raw_data = 0, + .raw_data_size = 0, + .send_pid = false, + .num_copy_handles = 0, + .num_move_handles = 0, + .num_objects = 0, + .copy_handles = NULL, + .move_handles = NULL, + .objects = NULL, + .close_object = false +}; + +ipc_response_fmt_t ipc_default_response_fmt = { + .num_copy_handles = 0, + .num_move_handles = 0, + .num_objects = 0, + .copy_handles = NULL, + .move_handles = NULL, + .objects = NULL, + + .raw_data_size = 0, + .raw_data = NULL, + + .has_pid = false, + .pid = NULL +}; + +result_t ipc_marshal(u32 *buffer, ipc_request_t *rq, ipc_object_t object) { + int h = 0; // h is for HEAD + + ipc_buffer_t *a_descriptors[16]; + ipc_buffer_t *b_descriptors[16]; + ipc_buffer_t *c_descriptors[16]; + ipc_buffer_t *x_descriptors[16]; + + int num_a_descriptors = 0, num_b_descriptors = 0, + num_c_descriptors = 0, num_x_descriptors = 0; + + bool to_domain = object.object_id >= 0; + + // group buffers by descriptor type + for(int i = 0; i < rq->num_buffers; i++) { + ipc_buffer_t *buffer = rq->buffers[i]; + + int direction = (buffer->type & 0b0011) >> 0; // in or out (ax or bc) + int family = (buffer->type & 0b1100) >> 2; // ab or xc + + if(!(buffer->type & 0x20)) { + ipc_buffer_t **list; + int *count; + + if(direction == 0b01) { // IN (ax) + if(family == 0b01) { // A + list = a_descriptors; + count = &num_a_descriptors; + } else if(family == 0b10) { // X + list = x_descriptors; + count = &num_x_descriptors; + } else { + return LIBTRANSISTOR_ERR_UNSUPPORTED_BUFFER_TYPE; + } + } else if(direction == 0b10) { // OUT (bc) + if(family == 0b01) { // B + list = b_descriptors; + count = &num_b_descriptors; + } else if(family == 0b10) { // C + list = c_descriptors; + count = &num_c_descriptors; + } else { + return LIBTRANSISTOR_ERR_UNSUPPORTED_BUFFER_TYPE; + } + } else { + return LIBTRANSISTOR_ERR_UNSUPPORTED_BUFFER_TYPE; + } + + // make sure we don't overflow our descriptor count fields + if(*count >= 16) { + return LIBTRANSISTOR_ERR_TOO_MANY_BUFFERS; + } + + // add the buffer to the list + list[(*count)++] = buffer; + } else { // flag 0x20 set + // this isn't entirely correct. the nintendo code is kinda complicated though + if(buffer->type == 0x21) { // IN (ax) + if(num_a_descriptors >= 16 || num_x_descriptors >= 16) { + return LIBTRANSISTOR_ERR_TOO_MANY_BUFFERS; + } + a_descriptors[num_a_descriptors++] = buffer; + x_descriptors[num_x_descriptors++] = &null_buffer; + } else if(buffer->type == 0x22) { // OUT (bc) + if(num_b_descriptors >= 16 || num_c_descriptors >= 16) { + return LIBTRANSISTOR_ERR_TOO_MANY_BUFFERS; + } + b_descriptors[num_b_descriptors++] = buffer; + c_descriptors[num_c_descriptors++] = &null_buffer; + } else { + return LIBTRANSISTOR_ERR_UNSUPPORTED_BUFFER_TYPE; + } + } + } + + // type must fit within 16 bits + if(rq->type & ~0xFFFF) { + return LIBTRANSISTOR_ERR_INVALID_REQUEST_TYPE; + } + + // header field 1 + buffer[h++] = rq->type + | (num_x_descriptors << 16) + | (num_a_descriptors << 20) + | (num_b_descriptors << 24) + | (0 << 28); // "w" descriptors + + int c_descriptor_flags = 0; + if(num_c_descriptors == 1) { + c_descriptor_flags = 2; + } else if(num_c_descriptors > 1) { + c_descriptor_flags = num_c_descriptors + 2; + } + + if(rq->raw_data_size & 3) { + return LIBTRANSISTOR_ERR_INVALID_RAW_DATA_SIZE; + } + + int raw_data_words = rq->raw_data_size / sizeof(uint32_t); + int raw_data_section_size = raw_data_words + + 4 // SFCI + command ID + + 4 // padding + + (to_domain ? 4 + rq->num_objects : 0); // domain header and in objects + + int num_move_handles = rq->num_move_handles; + if(!to_domain) { // not sure if this is actually legit or not + num_move_handles+= rq->num_objects; + } + + int handle_descriptor_enabled = rq->num_copy_handles || num_move_handles || rq->send_pid; + + // header field 2 + buffer[h++] = raw_data_section_size + | (c_descriptor_flags << 10) + | (handle_descriptor_enabled << 31); + + // handle descriptor + if(handle_descriptor_enabled) { + if(rq->num_copy_handles >= 16 || num_move_handles >= 16) { + return LIBTRANSISTOR_ERR_TOO_MANY_HANDLES; + } + + buffer[h++] = (rq->send_pid ? 1 : 0) + | (rq->num_copy_handles << 1) + | (rq->num_move_handles << 5); + + h+= (rq->send_pid ? 2 : 0); + + for(int i = 0; i < rq->num_copy_handles; i++) { + buffer[h++] = rq->copy_handles[i]; + } + if(!to_domain) { + for(int i = 0; i < rq->num_objects; i++) { + ipc_object_t *tobject = rq->objects + i; + if(tobject->object_id >= 0) { + return LIBTRANSISTOR_ERR_CANT_SEND_DOMAIN_OBJECT_TO_SESSION; + } + buffer[h++] = tobject->session; + } + } + for(int i = 0; i < rq->num_move_handles; i++) { + buffer[h++] = rq->move_handles[i]; + } + } + + // x descriptors + for(int i = 0; i < num_x_descriptors; i++) { + int counter = i; + ipc_buffer_t *buf = x_descriptors[i]; + + if((u64) buf->addr >> 39) { + return LIBTRANSISTOR_ERR_INVALID_BUFFER_ADDRESS; + } + + if(buf->size >> 16) { + return LIBTRANSISTOR_ERR_INVALID_BUFFER_SIZE; + } + + buffer[h++] = counter + | (((u64) buf->addr >> 36) & 0b111) << 6 + | ((counter >> 9) & 0b111) << 9 + | (((u64) buf->addr >> 32) & 0b1111) << 12 + | (buf->size << 16); + + buffer[h++] = (u64) buf->addr & 0xFFFFFFFF; + } + + // a & b descriptors + for(int i = 0; i < num_a_descriptors + num_b_descriptors; i++) { + ipc_buffer_t *buf = ((i < num_a_descriptors) ? a_descriptors : (b_descriptors - num_a_descriptors))[i]; + + if((u64) buf->addr >> 39) { + dbg_printf("a descriptor addr too long: %p", buf->addr); + return LIBTRANSISTOR_ERR_INVALID_BUFFER_ADDRESS; + } + + if(buf->size >> 35) { + return LIBTRANSISTOR_ERR_INVALID_BUFFER_SIZE; + } + + buffer[h++] = buf->size & 0xFFFFFFFF; + buffer[h++] = (u64) buf->addr & 0xFFFFFFFF; + + if(buf->type >> 8) { + return LIBTRANSISTOR_ERR_INVALID_PROTECTION; + } + + buffer[h++] = (buf->type >> 6) // flags/permissions + | (((u64) buf->addr >> 36) & 0b111) << 2 + | ((buf->size >> 32) & 0b1111) << 24 + | (((u64) buf->addr >> 32) & 0b1111) << 28; + } + + // "w" descriptors would go here + + // raw data + // align head to 4 words + int raw_data_start = h; + h = (h + 3) & ~3; + int pre_padding = h - raw_data_start; // the padding before this section and after it needs to add up to be 0x10 bytes long + + int domain_header_location = h; + + if(to_domain) { + if(rq->num_objects > 8) { // server code responds with result code 0x1d60a + return LIBTRANSISTOR_ERR_TOO_MANY_OBJECTS; + } + buffer[h++] = (rq->close_object ? 2 : 1) + | (rq->num_objects << 8); // we OR in the data payload size later; + buffer[h++] = object.object_id; + h+= 2; // alignment + } + + int payload_start = h; + + if(!rq->close_object) { + buffer[h++] = *((uint32_t*) "SFCI"); + buffer[h++] = 0; + buffer[h++] = rq->request_id; + buffer[h++] = 0; + + for(int i = 0; i < raw_data_words; i++) { + buffer[h++] = rq->raw_data[i]; + } + } else { + if(!to_domain) { + return LIBTRANSISTOR_ERR_CANT_CLOSE_SESSIONS_LIKE_DOMAIN_OBJECTS; + } + if( + (rq->type != 4) || + (rq->num_buffers != 0) || + (rq->raw_data_size != 0) || + (rq->send_pid != false) || + (rq->num_copy_handles != 0) || + (rq->num_move_handles != 0) || + (rq->num_objects != 0)) { + return LIBTRANSISTOR_ERR_MALFORMED_CLOSE_REQUEST; + } + } + + if(to_domain) { + buffer[domain_header_location]|= ((h - payload_start) * sizeof(*buffer)) << 16; + for(int i = 0; i < rq->num_objects; i++) { + if(rq->objects[i].domain != object.domain) { + return LIBTRANSISTOR_ERR_CANT_SEND_OBJECT_ACROSS_DOMAINS; + } + buffer[h++] = rq->objects[i].object_id; + } + } + + h+= 0x10 - pre_padding; + + int u16_length_count; + uint16_t *u16_length_list = (uint16_t*) (buffer + h); + + // c descriptor u16 length list + for(int i = 0; i < num_c_descriptors; i++) { + ipc_buffer_t *buf = c_descriptors[i]; + if(!(buf->type & 0x10)) { // u16 length list flag + if(buf->size >> 16) { + return LIBTRANSISTOR_ERR_INVALID_BUFFER_SIZE; + } + u16_length_list[u16_length_count++] = buf->size; + } + } + h+= (u16_length_count + 1) >> 1; + + // c descriptors + for(int i = 0; i < num_c_descriptors; i++) { + ipc_buffer_t *buf = c_descriptors[i]; + + if((u64) buf->addr >> 48) { + return LIBTRANSISTOR_ERR_INVALID_BUFFER_ADDRESS; + } + + if(buf->size >> 16) { + return LIBTRANSISTOR_ERR_INVALID_BUFFER_SIZE; + } + + buffer[h++] = (u64) buf->addr & 0xFFFFFFFF; + buffer[h++] = ((u64) buf->addr >> 32) + | (buf->size << 16); + } + + return RESULT_OK; +} + +result_t ipc_unmarshal(u32 *buffer, ipc_response_fmt_t *rs, ipc_object_t object) { + if(rs->raw_data_size & 3) { + return LIBTRANSISTOR_ERR_INVALID_RAW_DATA_SIZE; + } + + bool from_domain = object.object_id >= 0; + + int raw_data_words = rs->raw_data_size / sizeof(uint32_t); + + int h = 0; // h for HEAD + + u32 header0 = buffer[h++]; + u32 header1 = buffer[h++]; + int response_type = header0 & 0xFFFF; + + if(response_type != 0) { + return LIBTRANSISTOR_ERR_INVALID_IPC_RESPONSE_TYPE; + } + + int num_x_descriptors = (header0 >> 16) & 0xF; + int num_a_descriptors = (header0 >> 20) & 0xF; + int num_b_descriptors = (header0 >> 24) & 0xF; + int num_w_descriptors = (header0 >> 28) & 0xF; + + int raw_data_section_size = header1 & 0b1111111111; + + int c_descriptor_flags = (header1 >> 10) & 0xF; + bool has_handle_descriptor = header1 >> 31; + + int num_copy_handles = 0; + int num_move_handles = 0; + handle_t *copy_handles; + handle_t *move_handles; + + bool has_pid = false; + int pid; + + if(has_handle_descriptor) { + int handle_descriptor = buffer[h++]; + if(handle_descriptor & 1) { + has_pid = true; + pid = *(u64*)(buffer + h); + h+= 2; + } + num_copy_handles = (handle_descriptor >> 1) & 0xF; + num_move_handles = (handle_descriptor >> 5) & 0xF; + copy_handles = buffer + h; h+= num_copy_handles; + move_handles = buffer + h; h+= num_move_handles; + } + + // skip descriptors + h+= num_x_descriptors * 2; + h+= num_a_descriptors * 3; + h+= num_b_descriptors * 3; + h+= num_w_descriptors * 3; + + // align head to 4 words + int raw_data_start = h; + h = (h + 3) & ~3; + + int domain_header_location = h; + + if(from_domain) { + h+= 4; + } + + if(buffer[h++] != *((uint32_t*) "SFCO")) { + return LIBTRANSISTOR_ERR_INVALID_IPC_RESPONSE_MAGIC; + } + h++; + + // if this isn't ok, none of our other expectations will make + // sense, so this is the most meaningful result to return. + result_t response_code = buffer[h++]; + if(response_code != RESULT_OK) { + return response_code; + } + h++; + + u32 *raw_data = buffer + h; + + if((raw_data_section_size + - 4 // SFCI, command id + - 4 // padding + - (from_domain ? 4 + rs->num_objects : 0) // domain header + out objects + ) != raw_data_words) { + return LIBTRANSISTOR_ERR_UNEXPECTED_RAW_DATA_SIZE; + } + + if(has_pid != rs->has_pid) { + return LIBTRANSISTOR_ERR_UNEXPECTED_PID; + } + + if(num_copy_handles != rs->num_copy_handles) { + return LIBTRANSISTOR_ERR_UNEXPECTED_COPY_HANDLES; + } + + if(num_move_handles != rs->num_move_handles + (from_domain ? 0 : rs->num_objects)) { + return LIBTRANSISTOR_ERR_UNEXPECTED_MOVE_HANDLES; + } + + if(from_domain) { + uint8_t *domain_header = (uint8_t*) (buffer + domain_header_location); + uint8_t command = domain_header[0]; + uint8_t object_count = domain_header[1]; + uint16_t raw_data_size = ((uint16_t*) domain_header)[1]; + + if(command != 0) { + return LIBTRANSISTOR_ERR_UNEXPECTED_DOMAIN_HEADER_COMMAND; + } + + if(object_count != rs->num_objects) { + return LIBTRANSISTOR_ERR_UNEXPECTED_OBJECTS; + } + + uint32_t *domain_ids = (uint32_t*) (domain_header + 16 + raw_data_size); + for(int i = 0; i < rs->num_objects; i++) { + rs->objects[i].domain = object.domain; + rs->objects[i].object_id = domain_ids[i]; + } + } + + for(int i = 0; i < rs->num_copy_handles; i++) { rs->copy_handles[i] = copy_handles[i]; } + int mhi = 0; // move handle index + if(!from_domain) { + for(int i = 0; i < rs->num_objects; i++) { + rs->objects[i].session = move_handles[mhi++]; + rs->objects[i].object_id = -1; + } + } + for(int i = 0; i < rs->num_move_handles; i++) { rs->move_handles[i] = move_handles[mhi++]; } + for(int i = 0; i < raw_data_words; i++) { + rs->raw_data[i] = raw_data[i]; + } + + return RESULT_OK; +} + +result_t ipc_convert_to_domain(ipc_object_t *object, ipc_domain_t *domain) { + ipc_object_t session = *object; + domain->session = session.session; + + if(object->object_id != -1) { + return LIBTRANSISTOR_ERR_ALREADY_A_DOMAIN; + } + + object->domain = domain; + + ipc_request_t rq = ipc_default_request; + rq.type = 5; + rq.request_id = 0; + + ipc_response_fmt_t rs = ipc_default_response_fmt; + rs.raw_data_size = sizeof(object->object_id); + rs.raw_data = (uint32_t*) &(object->object_id); + + return ipc_send(session, &rq, &rs); +} + +result_t ipc_send(ipc_object_t object, ipc_request_t *rq, ipc_response_fmt_t *rs) { + result_t r; + u32 *tls = get_tls(); + r = ipc_marshal(tls, rq, object); if(r) { return r; } + r = svcSendSyncRequest(object.object_id >= 0 ? object.domain->session : object.session); if(r) { return r; } + r = ipc_unmarshal(tls, rs, object); if(r) { return r; } + + return RESULT_OK; +} + +result_t ipc_close(ipc_object_t object) { + if(object.object_id < 0) { + return svcCloseHandle(object.session); + } + + ipc_request_t rq = ipc_default_request; + rq.close_object = true; + + u32 *tls = get_tls(); + + result_t r; + r = ipc_marshal(tls, &rq, object); if(r) { return r; } + r = svcSendSyncRequest(object.domain->session); if (r) { return r; } + + // remote end doesn't seem to actually write a response + + return RESULT_OK; +} + +result_t ipc_close_domain(ipc_domain_t domain) { + return svcCloseHandle(domain.session); +} diff --git a/test/lib/ipc/bsd.c b/test/lib/ipc/bsd.c new file mode 100644 index 0000000..c27f165 --- /dev/null +++ b/test/lib/ipc/bsd.c @@ -0,0 +1,850 @@ +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#define TRANSFER_MEM_SIZE 256*1024 + +result_t bsd_result; +int bsd_errno; + +static ipc_domain_t bsd_domain; +static ipc_object_t bsd_object; + +static ipc_object_t iresolver_object; + +static uint8_t __attribute__((aligned(0x1000))) transfer_buffer[TRANSFER_MEM_SIZE]; +static transfer_memory_h transfer_mem; + +result_t bsd_init() { + result_t r; + r = sm_get_service(&bsd_object, "bsd:u"); + if(r) { + r = sm_get_service(&bsd_object, "bsd:s"); + if(r) { return r; } + } + + dbg_printf("connected to bsd"); + + r = ipc_convert_to_domain(&bsd_object, &bsd_domain); + if(r) { + ipc_close_domain(bsd_domain); + return r; + } + + dbg_printf("converted bsd to domain"); + + r = sm_get_service(&iresolver_object, "sfdnsres"); + if(r) { + ipc_close_domain(bsd_domain); + return r; + } + + dbg_printf("connected to sfdnsres"); + + r = svcCreateTransferMemory(&transfer_mem, transfer_buffer, TRANSFER_MEM_SIZE, 0); + if(r) { + ipc_close_domain(bsd_domain); + ipc_close(iresolver_object); + return r; + } + + uint64_t raw[] = {32*1024, 32*1024, 16*1024, 16*1024, + 0, // server copies pid to here + TRANSFER_MEM_SIZE}; + + ipc_request_t rq = ipc_default_request; + rq.type = 4; + rq.request_id = 0; + rq.raw_data = (uint32_t*) raw; + rq.raw_data_size = sizeof(raw); + rq.send_pid = true; + rq.num_copy_handles = 1; + rq.copy_handles = &transfer_mem; + + uint32_t response[1]; + + ipc_response_fmt_t rs = ipc_default_response_fmt; + rs.raw_data_size = sizeof(response); + rs.raw_data = response; + + r = ipc_send(bsd_object, &rq, &rs); // not working under mephisto + + if(r) { + svcCloseHandle(transfer_mem); + ipc_close_domain(bsd_domain); + ipc_close(iresolver_object); + return r; + } + + if(response[0]) { + bsd_errno = response[0]; + svcCloseHandle(transfer_mem); + ipc_close_domain(bsd_domain); + ipc_close(iresolver_object); + return LIBTRANSISTOR_ERR_BSD_ERRNO_SET; + } + + return 0; +} + +// def tested via PS +// impl tested via Mephisto +int bsd_socket(int domain, int type, int protocol) { + result_t r; + + uint32_t raw[] = {domain, type, protocol}; + + ipc_request_t rq = ipc_default_request; + rq.request_id = 2; + rq.raw_data = raw; + rq.raw_data_size = sizeof(raw); + + int32_t response[2]; // fd, errno + + ipc_response_fmt_t rs = ipc_default_response_fmt; + rs.raw_data_size = sizeof(response); + rs.raw_data = (uint32_t*) response; + + r = ipc_send(bsd_object, &rq, &rs); + if(r) { + bsd_result = r; + return -1; + } + + if(response[0] < 0) { + bsd_result = LIBTRANSISTOR_ERR_BSD_ERRNO_SET; + bsd_errno = response[1]; + return -1; + } + + return response[0]; +} + +// def tested via PS +// impl untested +int bsd_recv(int socket, void *message, size_t length, int flags) { + result_t r; + + uint32_t raw[] = {socket, flags}; + + ipc_buffer_t buffer; + buffer.addr = message; + buffer.size = length; + buffer.type = 0x22; + + ipc_buffer_t *buffers[] = {&buffer}; + + ipc_request_t rq = ipc_default_request; + rq.num_buffers = 1; + rq.buffers = buffers; + rq.request_id = 8; + rq.raw_data = raw; + rq.raw_data_size = sizeof(raw); + + int32_t response[2]; // ret, errno + + ipc_response_fmt_t rs = ipc_default_response_fmt; + rs.raw_data_size = sizeof(response); + rs.raw_data = (uint32_t*) response; + + r = ipc_send(bsd_object, &rq, &rs); + if(r) { + bsd_result = r; + return -1; + } + + if(response[0] < 0) { + bsd_result = LIBTRANSISTOR_ERR_BSD_ERRNO_SET; + bsd_errno = response[1]; + return -1; + } + + return response[0]; +} + +// def tested via PS +// impl tested via Mephisto +int bsd_send(int socket, const void *data, size_t length, int flags) { + result_t r; + + uint32_t raw[] = {socket, flags}; + + ipc_buffer_t buffer; + buffer.addr = (void*) data; + buffer.size = length; + buffer.type = 0x21; // A+X + + ipc_buffer_t *buffers[] = {&buffer}; + + ipc_request_t rq = ipc_default_request; + rq.num_buffers = 1; + rq.buffers = buffers; + rq.request_id = 10; + rq.raw_data = raw; + rq.raw_data_size = sizeof(raw); + + int32_t response[2]; // ret, errno + + ipc_response_fmt_t rs = ipc_default_response_fmt; + rs.raw_data_size = sizeof(response); + rs.raw_data = (uint32_t*) response; + + r = ipc_send(bsd_object, &rq, &rs); + if(r) { + bsd_result = r; + return -1; + } + + if(response[0] < 0) { + bsd_result = LIBTRANSISTOR_ERR_BSD_ERRNO_SET; + bsd_errno = response[1]; + return -1; + } + + return response[0]; +} + +// def tested via PS +// impl untested +int bsd_sendto(int socket, const void *message, size_t length, int flags, const struct sockaddr *dest_addr, socklen_t dest_len) { + result_t r; + + uint32_t raw[] = {socket, flags}; + + ipc_buffer_t message_buffer; + message_buffer.addr = (void*) message; + message_buffer.size = length; + message_buffer.type = 0x21; // A+X + + ipc_buffer_t addr_buffer; + addr_buffer.addr = (void*) dest_addr; + addr_buffer.size = dest_len; + addr_buffer.type = 0x21; // A+X + + ipc_buffer_t *buffers[] = {&message_buffer, &addr_buffer}; + + ipc_request_t rq = ipc_default_request; + rq.num_buffers = 2; + rq.buffers = buffers; + rq.request_id = 11; + rq.raw_data = raw; + rq.raw_data_size = sizeof(raw); + + int32_t response[2]; // ret, errno + + ipc_response_fmt_t rs = ipc_default_response_fmt; + rs.raw_data_size = sizeof(response); + rs.raw_data = (uint32_t*) response; + + r = ipc_send(bsd_object, &rq, &rs); + if(r) { + bsd_result = r; + return -1; + } + + if(response[0] < 0) { + bsd_result = LIBTRANSISTOR_ERR_BSD_ERRNO_SET; + bsd_errno = response[1]; + return -1; + } + + return response[0]; +} + +// def tested via PS +// impl untested +int bsd_accept(int socket, struct sockaddr *restrict address, socklen_t *restrict address_len) { + result_t r; + + uint32_t raw[] = {socket}; + + ipc_buffer_t addr_buffer; + addr_buffer.addr = (void*) address; + addr_buffer.size = *address_len; + addr_buffer.type = 0x22; + + ipc_buffer_t *buffers[] = {&addr_buffer}; + + ipc_request_t rq = ipc_default_request; + rq.num_buffers = 1; + rq.buffers = buffers; + rq.request_id = 12; + rq.raw_data = raw; + rq.raw_data_size = sizeof(raw); + + int32_t response[3]; // ret, errno, address_len + + ipc_response_fmt_t rs = ipc_default_response_fmt; + rs.raw_data_size = sizeof(response); + rs.raw_data = (uint32_t*) response; + + r = ipc_send(bsd_object, &rq, &rs); + if(r) { + bsd_result = r; + return -1; + } + + if(response[0] < 0) { + bsd_result = LIBTRANSISTOR_ERR_BSD_ERRNO_SET; + bsd_errno = response[1]; + return -1; + } + + *address_len = response[2]; + + return response[0]; +} + +// def tested via PS +// impl untested +int bsd_bind(int socket, const struct sockaddr *address, socklen_t address_len) { + result_t r; + + uint32_t raw[] = {socket}; + + ipc_buffer_t buffer; + buffer.addr = (void*) address; + buffer.size = address_len; + buffer.type = 0x21; // A+X + + ipc_buffer_t *buffers[] = {&buffer}; + + ipc_request_t rq = ipc_default_request; + rq.num_buffers = 1; + rq.buffers = buffers; + rq.request_id = 13; + rq.raw_data = raw; + rq.raw_data_size = sizeof(raw); + + int32_t response[2]; // ret, errno + + ipc_response_fmt_t rs = ipc_default_response_fmt; + rs.raw_data_size = sizeof(response); + rs.raw_data = (uint32_t*) response; + + r = ipc_send(bsd_object, &rq, &rs); + if(r) { + bsd_result = r; + return -1; + } + + if(response[0] < 0) { + bsd_result = LIBTRANSISTOR_ERR_BSD_ERRNO_SET; + bsd_errno = response[1]; + return -1; + } + + return response[0]; +} + +// def tested via PS +// impl tested via Mephisto +int bsd_connect(int socket, const struct sockaddr *address, socklen_t address_len) { + result_t r; + + uint32_t raw[] = {socket}; + + ipc_buffer_t buffer; + buffer.addr = (void*) address; + buffer.size = address_len; + buffer.type = 0x21; // A+X + + ipc_buffer_t *buffers[] = {&buffer}; + + ipc_request_t rq = ipc_default_request; + rq.num_buffers = 1; + rq.buffers = buffers; + rq.request_id = 14; + rq.raw_data = raw; + rq.raw_data_size = sizeof(raw); + + uint32_t response[2]; // ret, errno + + ipc_response_fmt_t rs = ipc_default_response_fmt; + rs.raw_data_size = sizeof(response); + rs.raw_data = response; + + r = ipc_send(bsd_object, &rq, &rs); + if(r) { + bsd_result = r; + return -1; + } + + if(response[0] != 0) { + bsd_result = LIBTRANSISTOR_ERR_BSD_ERRNO_SET; + bsd_errno = response[1]; + return -1; + } + + return response[0]; +} + +// def untested +int bsd_getsockname(int socket, struct sockaddr *restrict address, socklen_t *restrict address_len) { + return 0; +} + +// def tested via PS +int bsd_listen(int socket, int backlog) { + result_t r; + + uint32_t raw[] = {socket, backlog}; + + ipc_request_t rq = ipc_default_request; + rq.request_id = 18; + rq.raw_data = raw; + rq.raw_data_size = sizeof(raw); + + int32_t response[2]; // ret, errno + + ipc_response_fmt_t rs = ipc_default_response_fmt; + rs.raw_data_size = sizeof(response); + rs.raw_data = (uint32_t*) response; + + r = ipc_send(bsd_object, &rq, &rs); + if(r) { + bsd_result = r; + return -1; + } + + if(response[0] < 0) { + bsd_result = LIBTRANSISTOR_ERR_BSD_ERRNO_SET; + bsd_errno = response[1]; + return -1; + } + + return response[0]; +} + +// def untested +int bsd_setsockopt(int socket, int level, int option_name, const void *option_value, socklen_t option_len) { + return 0; +} + +// def untested +int bsd_shutdown(int socket, int how) { + return 0; +} + +// def untested +int bsd_select(int nfds, fd_set *restrict readfds, fd_set *restrict writefds, fd_set *restrict errorfds, struct timeval *restrict timeout) { + result_t r; + + uint64_t timeout_words[3]; + if(timeout != NULL) { + timeout_words[0] = timeout->tv_sec; + timeout_words[1] = timeout->tv_usec; + timeout_words[2] = 0; + } else { + timeout_words[0] = 0; + timeout_words[1] = 0; + timeout_words[2] = 1; + } + + uint32_t raw[7]; + raw[0] = nfds; + memcpy(raw + 1, timeout_words, sizeof(timeout_words)); + + ipc_buffer_t readfds_in = { + .addr = readfds, + .size = (readfds == NULL) ? 0 : sizeof(readfds), + .type = 0x21 + }; + ipc_buffer_t writefds_in = { + .addr = writefds, + .size = (writefds == NULL) ? 0 : sizeof(writefds), + .type = 0x21 + }; + ipc_buffer_t errorfds_in = { + .addr = errorfds, + .size = (errorfds == NULL) ? 0 : sizeof(errorfds), + .type = 0x21 + }; + ipc_buffer_t readfds_out = { + .addr = readfds, + .size = (readfds == NULL) ? 0 : sizeof(readfds), + .type = 0x22 + }; + ipc_buffer_t writefds_out = { + .addr = writefds, + .size = (writefds == NULL) ? 0 : sizeof(writefds), + .type = 0x22 + }; + ipc_buffer_t errorfds_out = { + .addr = errorfds, + .size = (errorfds == NULL) ? 0 : sizeof(errorfds), + .type = 0x22 + }; + + ipc_buffer_t *buffers[] = { + &readfds_in, + &writefds_in, + &errorfds_in, + &readfds_out, + &writefds_out, + &errorfds_out + }; + + ipc_request_t rq = ipc_default_request; + rq.num_buffers = 6; + rq.buffers = buffers; + rq.request_id = 5; + rq.raw_data = raw; + rq.raw_data_size = sizeof(raw); + + int32_t response[2]; + + ipc_response_fmt_t rs = ipc_default_response_fmt; + rs.raw_data_size = sizeof(response); + rs.raw_data = (uint32_t*) response; + + r = ipc_send(bsd_object, &rq, &rs); + if(r) { + bsd_result = r; + return -1; + } + + if(response[0] < 0) { + bsd_result = LIBTRANSISTOR_ERR_BSD_ERRNO_SET; + bsd_errno = response[1]; + return -1; + } + + return response[0]; +} + +int bsd_getaddrinfo(const char *node, const char *service, const struct addrinfo *hints, struct addrinfo **res) { + result_t r; + + struct { + uint8_t enable_nsd_resolve; + uint8_t padding[3]; + uint32_t unknown; + uint64_t pid; + } __attribute__((packed)) raw; + + raw.enable_nsd_resolve = 1; + raw.unknown = 0; + raw.pid = 0; + + uint8_t hints_packed[0x400]; + uint8_t response_packed[0x1000]; + + memset(hints_packed, 0, sizeof(hints_packed)); + if(hints != NULL) { + r = bsd_ai_pack(hints, hints_packed, sizeof(hints_packed)); + if(r) { + bsd_result = r; + return -1; + } + } + + ipc_buffer_t host_buf = { + .addr = (void*) node, + .size = (node == NULL) ? 0 : strlen(node)+1, + .type = 5 + }; + ipc_buffer_t service_buf = { + .addr = (void*) service, + .size = (service == NULL) ? 0 : strlen(service)+1, + .type = 5 + }; + ipc_buffer_t hints_buf = { + .addr = hints_packed, + .size = (hints == NULL) ? 0 : sizeof(hints_packed), + .type = 5 + }; + ipc_buffer_t response_buf = { + .addr = response_packed, + .size = sizeof(response_packed), + .type = 6 + }; + + ipc_buffer_t *buffers[] = { + &host_buf, + &service_buf, + &hints_buf, + &response_buf + }; + + ipc_request_t rq = ipc_default_request; + rq.num_buffers = 4; + rq.buffers = buffers; + rq.request_id = 6; + rq.raw_data = (uint32_t*) &raw; + rq.raw_data_size = sizeof(raw); + rq.send_pid = true; + + int32_t response[3]; // ret, errno, response_size + + ipc_response_fmt_t rs = ipc_default_response_fmt; + rs.raw_data_size = sizeof(response); + rs.raw_data = (uint32_t*) response; + + r = ipc_send(iresolver_object, &rq, &rs); + if(r) { + bsd_result = r; + return -1; + } + + if(response[0] < 0) { + bsd_result = LIBTRANSISTOR_ERR_BSD_ERRNO_SET; + bsd_errno = response[1]; + return -1; + } + + r = bsd_ai_unpack(res, response_packed, response[2]); + if(r) { + bsd_result = r; + return -1; + } + + return response[0]; +} + +// def tested via PS +int bsd_close(int socket) { + result_t r; + + uint32_t raw[] = {socket}; + + ipc_request_t rq = ipc_default_request; + rq.request_id = 26; + rq.raw_data = raw; + rq.raw_data_size = sizeof(raw); + + int32_t response[2]; // ret, errno + + ipc_response_fmt_t rs = ipc_default_response_fmt; + rs.raw_data_size = sizeof(response); + rs.raw_data = (uint32_t*) response; + + r = ipc_send(bsd_object, &rq, &rs); + if(r) { + bsd_result = r; + return -1; + } + + if(response[0] < 0) { + bsd_result = LIBTRANSISTOR_ERR_BSD_ERRNO_SET; + bsd_errno = response[1]; + return -1; + } + + return response[0]; +} + +void bsd_finalize() { + svcCloseHandle(transfer_mem); + ipc_close(bsd_object); + ipc_close_domain(bsd_domain); +} + +result_t bsd_ai_pack(const struct addrinfo *ai, uint8_t *buf, int size) { + struct { + uint32_t magic; + int32_t ai_flags; + int32_t ai_family; + int32_t ai_socktype; + int32_t ai_protocol; + int32_t ai_addrlen; + } __attribute__((packed)) ai_packed_header = { + htonl(0xBEEFCAFE), + htonl(ai->ai_flags), + htonl(ai->ai_family), + htonl(ai->ai_socktype), + htonl(ai->ai_protocol), + htonl(ai->ai_addrlen) + }; + + if(size < sizeof(ai_packed_header)) { + return LIBTRANSISTOR_ERR_BSD_BUFFER_TOO_SMALL; + } + + memcpy(buf, &ai_packed_header, sizeof(ai_packed_header)); + buf+= sizeof(ai_packed_header); + size-= sizeof(ai_packed_header); + + if(size < (ai->ai_addrlen == 0 ? 4 : ai->ai_addrlen)) { + return LIBTRANSISTOR_ERR_BSD_BUFFER_TOO_SMALL; + } + + if(ai->ai_addrlen == 0) { + *((uint32_t*) buf) = 0; + } else { + switch(ai->ai_family) { + case AF_INET: { + struct sockaddr_in *buf_as_sockaddr_in = (struct sockaddr_in*) buf; + struct sockaddr_in *sockaddr = (struct sockaddr_in*) ai->ai_addr; + //buf_as_sockaddr_in->sin_len = 0; + buf_as_sockaddr_in->sin_family = sockaddr->sin_family; + buf_as_sockaddr_in->sin_port = htons(sockaddr->sin_port); // I think that this is erroneously byteswapped + buf_as_sockaddr_in->sin_addr.s_addr = htonl(sockaddr->sin_addr.s_addr); // this too + memset(&buf_as_sockaddr_in->sin_zero, 0, sizeof(buf_as_sockaddr_in->sin_zero)); + break; + } + case AF_INET6: + // TODO + return LIBTRANSISTOR_ERR_UNIMPLEMENTED; + default: + memcpy(buf, ai->ai_addr, ai->ai_addrlen); + break; + } + } + buf+= ai->ai_addrlen; + size-= ai->ai_addrlen == 0 ? 4 : ai->ai_addrlen; + + int canonlen = ai->ai_canonname == NULL ? 0 : strlen(ai->ai_canonname); + if(size < canonlen + 1) { + return LIBTRANSISTOR_ERR_BSD_BUFFER_TOO_SMALL; + } + + memcpy(buf, ai->ai_canonname, canonlen); + buf[canonlen] = 0; + buf+= canonlen + 1; + size-= canonlen + 1; + + if(ai->ai_next != NULL) { + return bsd_ai_pack(ai->ai_next, buf, size); + } else { + if(size < 4) { + return LIBTRANSISTOR_ERR_BSD_BUFFER_TOO_SMALL; + } + *((uint32_t*) buf) = 0; + return 0; + } +} + +result_t bsd_ai_unpack(struct addrinfo **res, const uint8_t *buf, int size) { + struct { + uint32_t magic; + int32_t ai_flags; + int32_t ai_family; + int32_t ai_socktype; + int32_t ai_protocol; + int32_t ai_addrlen; + } __attribute__((packed)) ai_packed_header = {}; + + result_t r; + + struct addrinfo *ai; + + ai = malloc(sizeof(struct addrinfo)); + if(ai == NULL) { + return LIBTRANSISTOR_ERR_OUT_OF_MEMORY; + } + + memset(ai, 0, sizeof(struct addrinfo)); + + if(size < sizeof(ai_packed_header)) { + r = LIBTRANSISTOR_ERR_BSD_BUFFER_TOO_SMALL; + goto bail; + } + + memcpy(&ai_packed_header, buf, sizeof(ai_packed_header)); + buf+= sizeof(ai_packed_header); + size-= sizeof(ai_packed_header); + + if(ntohl(ai_packed_header.magic) != 0xBEEFCAFE) { + r = LIBTRANSISTOR_ERR_BSD_INVALID_MAGIC; + goto bail; + } + + ai->ai_flags = ntohl(ai_packed_header.ai_flags); + ai->ai_family = ntohl(ai_packed_header.ai_family); + ai->ai_socktype = ntohl(ai_packed_header.ai_socktype); + ai->ai_protocol = ntohl(ai_packed_header.ai_protocol); + ai->ai_addrlen = ntohl(ai_packed_header.ai_addrlen); + + if(ai->ai_addrlen == 0) { + ai->ai_addr = NULL; + buf+= 4; + size-= 4; + } else { + ai->ai_addr = malloc(ai->ai_addrlen); + if(ai->ai_addr == NULL) { + dbg_printf("could not allocate ai_addr, len: %d", ai->ai_addrlen); + r = LIBTRANSISTOR_ERR_OUT_OF_MEMORY; + goto bail; + } + switch(ai->ai_family) { + case AF_INET: { + struct sockaddr_in *buf_as_sockaddr_in = (struct sockaddr_in*) buf; + struct sockaddr_in *sockaddr = (struct sockaddr_in*) ai->ai_addr; + //sockaddr->sin_len = 0; + sockaddr->sin_family = buf_as_sockaddr_in->sin_family; + sockaddr->sin_port = htons(buf_as_sockaddr_in->sin_port); // erroneous byte swapping + sockaddr->sin_addr.s_addr = htonl(buf_as_sockaddr_in->sin_addr.s_addr); // again + memset(&sockaddr->sin_zero, 0, sizeof(sockaddr->sin_zero)); + break; + } + case AF_INET6: + // TODO + return LIBTRANSISTOR_ERR_UNIMPLEMENTED; + default: + memcpy(ai->ai_addr, buf, ai->ai_addrlen); + break; + } + buf+= ai->ai_addrlen; + size-= ai->ai_addrlen; + } + + int canonlen = strlen((char*) buf); + char *canonname; + if(canonlen > 0) { + canonname = malloc(canonlen+1); + if(canonname == NULL) { + r = LIBTRANSISTOR_ERR_OUT_OF_MEMORY; + goto bail; + } + memcpy(canonname, buf, canonlen+1); + } else { + canonname = NULL; + } + ai->ai_canonname = canonname; + + buf+= canonlen+1; + size-= canonlen+1; + + if(*((uint32_t*) buf) == htonl(0xBEEFCAFE)) { + r = bsd_ai_unpack(&ai->ai_next, buf, size); + if(r) { + goto bail; + } + } + + *res = ai; + return 0; + + bail: + if(ai->ai_addr != NULL) { + free(ai->ai_addr); + } + if(ai->ai_canonname != NULL) { + free(ai->ai_canonname); + } + free(ai); + return r; +} + +void bsd_freeaddrinfo(struct addrinfo *res) { + if(res->ai_next != NULL) { + bsd_freeaddrinfo(res->ai_next); + } + if(res->ai_addr != NULL) { + free(res->ai_addr); + } + if(res->ai_canonname != NULL) { + free(res->ai_canonname); + } + free(res); +} diff --git a/test/lib/ipc/sm.c b/test/lib/ipc/sm.c new file mode 100644 index 0000000..bcc7338 --- /dev/null +++ b/test/lib/ipc/sm.c @@ -0,0 +1,59 @@ +#include +#include +#include +#include +#include +#include + +#include + +static ipc_object_t sm_object; + +static u64 str2u64(char *str) { + char buf[8]; + int i = 0; + for(; i < 8; i++) { + if(str[i] == 0) { break; } + buf[i] = str[i]; + } + for(; i < 8; i++) { + buf[i] = 0; + } + return *(u64*) buf; +} + +result_t sm_init() { + dbg_printf("initializing sm"); + sm_object.object_id = -1; + return svcConnectToNamedPort(&(sm_object.session), "sm:"); +} + +void sm_finalize() { + ipc_close(sm_object); +} + +result_t sm_get_service(ipc_object_t *out_object, char *name) { + if(!sm_object.session) { + return LIBTRANSISTOR_ERR_SM_NOT_INITIALIZED; + } + + u64 service_name = str2u64(name); + int i; + + if(strlen(name) > 8) { + return LIBTRANSISTOR_ERR_SM_SERVICE_NAME_TOO_LONG; + } + + out_object->object_id = -1; + + ipc_request_t rq = ipc_default_request; + rq.request_id = 1; + rq.raw_data = (u32*) &service_name; + rq.raw_data_size = sizeof(service_name); + + ipc_response_fmt_t rs = ipc_default_response_fmt; + rs.num_move_handles = 1; + rs.move_handles = &(out_object->session); + + return ipc_send(sm_object, &rq, &rs); +} diff --git a/test/lib/ipcClients.h b/test/lib/ipcClients.h new file mode 100644 index 0000000..4c16f6c --- /dev/null +++ b/test/lib/ipcClients.h @@ -0,0 +1,27871 @@ +#pragma once +#include + +using ServiceName = uint8_t *; // uint8_t[8] + +class SmService; +namespace Pm { + class Bm; + class Shell; +} +namespace nn { + using ApplicationId = uint64_t; + using TimeSpan = uint64_t; + using TimeSpanType = uint64_t; +} +namespace nn::account { + using CallbackUri = uint8_t; + using NetworkServiceAccountId = uint64_t; + using Nickname = uint8_t *; // uint8_t[0x21] + using NintendoAccountAuthorizationRequestParameters = uint8_t; + using NintendoAccountId = uint64_t; + using ProfileDigest = uint128_t; + using RequestUrl = uint8_t; + using SystemProgramIdentification = uint8_t; + using Uid = uint128_t; + + class IAccountServiceForAdministrator; + class IAccountServiceForApplication; + class IAccountServiceForSystemService; + class IBaasAccessTokenAccessor; +} +namespace nn::account::baas { + class IAdministrator; + class IFloatingRegistrationRequest; + class IGuestLoginRequest; + class IManagerForApplication; + class IManagerForSystemService; +} +namespace nn::account::detail { + using Uuid = uint128_t; + + class IAsyncContext; + class INotifier; + class ISessionObject; +} +namespace nn::account::http { + class IOAuthProcedure; +} +namespace nn::account::nas { + using NasClientInfo = uint8_t; + using NasUserBase = uint8_t; + using NasUserBaseForApplication = uint8_t; + using State = uint8_t; + + class IAuthorizationRequest; + class IOAuthProcedureForExternalNsa; + class IOAuthProcedureForNintendoAccountLinkage; +} +namespace nn::account::profile { + using ProfileBase = uint8_t *; // uint8_t[0x38] + using UserData = uint8_t; + + class IProfile; + class IProfileEditor; +} +namespace nn::ahid { + class ICtrlSession; + class IReadSession; + class IServerSession; +} +namespace nn::ahid::hdr { + class ISession; +} +namespace nn::am { + using AppletAttribute = uint8_t; + using AppletMessage = uint32_t; +} +namespace nn::am::service { + using AppletIdentityInfo = uint128_t; + using AppletKind = uint64_t; + using AppletProcessLaunchReason = uint32_t; + using EmulatedButtonEvent = uint32_t; + using LibraryAppletInfo = uint64_t; + using WindowCreationOption = uint32_t; + + class IAllSystemAppletProxiesService; + class IAppletAccessor; + class IApplicationAccessor; + class IApplicationCreator; + class IApplicationFunctions; + class IApplicationProxy; + class IApplicationProxyService; + class IAudioController; + class ICommonStateGetter; + class IDebugFunctions; + class IDisplayController; + class IGlobalStateController; + class IHomeMenuFunctions; + class ILibraryAppletAccessor; + class ILibraryAppletCreator; + class ILibraryAppletProxy; + class ILibraryAppletSelfAccessor; + class ILockAccessor; + class IOverlayAppletProxy; + class IOverlayFunctions; + class IProcessWindingController; + class ISelfController; + class IStorage; + class IStorageAccessor; + class ISystemAppletProxy; + class ITransferStorageAccessor; + class IWindow; + class IWindowController; +} +namespace nn::aocsrv::detail { + class IAddOnContentManager; +} +namespace nn::apm { + using EventTarget = uint32_t; + using PerformanceConfiguration = uint32_t; + using PerformanceMode = uint32_t; + using ThrottlingState = uint8_t *; // uint8_t[0x28] + + class IManager; + class IManagerPrivileged; + class ISession; + class ISystemManager; +} +namespace nn::applet { + using AppletResourceUserId = uint64_t; +} +namespace nn::arp::detail { + class IReader; + class IRegistrar; + class IWriter; +} +namespace nn::audio::detail { + class IAudioDebugManager; + class IAudioDevice; + class IAudioIn; + class IAudioInManager; + class IAudioInManagerForApplet; + class IAudioInManagerForDebugger; + class IAudioOut; + class IAudioOutManager; + class IAudioOutManagerForApplet; + class IAudioOutManagerForDebugger; + class IAudioRenderer; + class IAudioRendererManager; + class IAudioRendererManagerForApplet; + class IAudioRendererManagerForDebugger; + class IFinalOutputRecorder; + class IFinalOutputRecorderManager; + class IFinalOutputRecorderManagerForApplet; + class IFinalOutputRecorderManagerForDebugger; +} +namespace nn::audioctrl::detail { + class IAudioController; +} +namespace nn::bcat { + using DeliveryCacheDirectoryEntry = uint8_t; + using Digest = uint128_t; + using DirectoryName = uint8_t *; // uint8_t[0x20] + using FileName = uint8_t *; // uint8_t[0x20] + using PushNotificationLog = uint8_t; + using TaskInfo = uint8_t; +} +namespace nn::bcat::detail { + using DeliveryCacheProgressImpl = uint8_t; +} +namespace nn::bcat::detail::ipc { + class IBcatService; + class IDeliveryCacheDirectoryService; + class IDeliveryCacheFileService; + class IDeliveryCacheProgressService; + class IDeliveryCacheStorageService; + class IServiceCreator; +} +namespace nn::bgtc { + class IStateControlService; + class ITaskService; +} +namespace nn::bluetooth { + using Address = uint8_t *; // uint8_t[6] + + class IBluetoothDriver; +} +namespace nn::bpc { + class IBoardPowerControlManager; + class IRtcManager; +} +namespace nn::bsdsocket::cfg { + class ServerInterface; +} +namespace nn::btm { + class IBtm; + class IBtmDebug; + class IBtmSystem; + class IBtmSystemCore; +} +namespace nn::capsrv { + using ApplicationAlbumEntry = uint8_t *; // uint8_t[0x20] +} +namespace nn::capsrv::detail { + using ScreenShotAttributeEx0 = uint8_t *; // uint8_t[0x40] +} +namespace nn::capsrv::sf { + class IAlbumAccessorService; + class IAlbumControlService; + class IScreenShotApplicationService; + class IScreenShotControlService; + class IScreenShotService; +} +namespace nn::cec { + class ICecManager; +} +namespace nn::codec::detail { + class IHardwareOpusDecoder; + class IHardwareOpusDecoderManager; +} +namespace nn::erpt::sf { + class IContext; + class IManager; + class IReport; + class ISession; +} +namespace nn::err { + using ErrorCode = uint64_t; +} +namespace nn::es { + class IETicketService; +} +namespace nn::eth::sf { + class IEthInterface; + class IEthInterfaceGroup; +} +namespace nn::eupld::sf { + class IControl; + class IRequest; +} +namespace nn::fan::detail { + class IController; + class IManager; +} +namespace nn::fatalsrv { + class IPrivateService; + class IService; +} +namespace nn::fgm { + using Module = uint32_t; +} +namespace nn::fgm::sf { + class IDebugger; + class IRequest; + class ISession; +} +namespace nn::friends { + using ApplicationInfo = uint128_t; + using ExternalApplicationCatalog = uint8_t; + using ExternalApplicationCatalogId = uint128_t; + using FacedFriendRequestRegistrationKey = uint8_t *; // uint8_t[0x40] + using FriendCode = uint8_t *; // uint8_t[0x20] + using InAppScreenName = uint8_t; + using MiiImageUrlParam = uint128_t; + using MiiName = uint8_t *; // uint8_t[0x20] + using NintendoNetworkIdUserInfo = uint8_t; + using PlayHistoryRegistrationKey = uint8_t; + using PlayHistoryStatistics = uint128_t; + using Relationship = uint64_t; + using RequestId = uint64_t; + using Url = uint8_t *; // uint8_t[0xa0] +} +namespace nn::friends::detail { + using BlockedUserImpl = uint8_t; + using FriendCandidateImpl = uint8_t; + using FriendDetailedInfoImpl = uint8_t; + using FriendImpl = uint8_t; + using FriendRequestImpl = uint8_t; + using FriendSettingImpl = uint8_t; + using NintendoNetworkIdFriendImpl = uint8_t; + using PlayHistoryImpl = uint8_t; + using ProfileExtraImpl = uint8_t; + using ProfileImpl = uint8_t; + using UserPresenceImpl = uint8_t; + using UserPresenceViewImpl = uint8_t; + using UserSettingImpl = uint8_t; +} +namespace nn::friends::detail::ipc { + using SizedFriendFilter = uint128_t; + using SizedNotificationInfo = uint128_t; + + class IFriendService; + class INotificationService; + class IServiceCreator; +} +namespace nn::fssrv::sf { + using Partition = uint32_t; + using SaveCreateStruct = uint8_t *; // uint8_t[0x40] + using SaveStruct = uint8_t *; // uint8_t[0x40] + + class IDeviceOperator; + class IDirectory; + class IEventNotifier; + class IFile; + class IFileSystem; + class IFileSystemProxy; + class IFileSystemProxyForLoader; + class IProgramRegistry; + class ISaveDataInfoReader; + class IStorage; +} +namespace nn::gpio { + class IManager; + class IPadSession; +} +namespace nn::hid { + using BasicXpadId = uint32_t; + using ConsoleSixAxisSensorHandle = uint32_t; + using JoyXpadId = uint32_t; + using NpadStyleTag = uint32_t; + using SixAxisSensorHandle = uint32_t; + using TouchState = uint8_t; + using VibrationDeviceHandle = uint32_t; + using VibrationDeviceInfoForIpc = uint64_t; + using VibrationValue = uint128_t; + + class IActiveVibrationDeviceList; + class IAppletResource; + class IHidDebugServer; + class IHidServer; + class IHidSystemServer; + class IHidTemporaryServer; +} +namespace nn::hid::debug { + using BasicXpadAutoPilotState = uint8_t *; // uint8_t[0x1c] + using CaptureButtonAutoPilotState = uint64_t; + using DebugPadAutoPilotState = uint8_t *; // uint8_t[0x18] + using HomeButtonAutoPilotState = uint64_t; + using KeyboardAutoPilotState = uint8_t *; // uint8_t[0x28] + using MouseAutoPilotState = uint8_t *; // uint8_t[0x1c] + using SleepButtonAutoPilotState = uint64_t; +} +namespace nn::hid::system { + using DeviceType = uint32_t; + using FirmwareUpdateDeviceHandle = uint64_t; + using FirmwareUpdateState = uint32_t; + using FirmwareVersion = uint128_t; + using InputSourceId = uint32_t; + using KeyboardLockKeyEvent = uint32_t; + using PlayReportControllerUsage = uint8_t; + using RegisteredDevice = uint8_t; + using UniquePadId = uint64_t; + using UniqueSixAxisSensorHandle = uint32_t; +} +namespace nn::hid::tmp { + using ConsoleSixAxisSensorCalibrationValues = uint8_t *; // uint8_t[0x18] +} +namespace nn::htc::tenv { + class IService; + class IServiceManager; +} +namespace nn::i2c { + class IManager; + class ISession; +} +namespace nn::idle::detail { + class IPolicyManagerSystem; +} +namespace nn::irsensor { + using ImageTransferProcessorState = uint128_t; + using IrCameraHandle = uint32_t; + using PackedClusteringProcessorConfig = uint8_t *; // uint8_t[0x28] + using PackedDpdProcessorConfig = uint8_t *; // uint8_t[0xc] + using PackedImageTransferProcessorConfig = uint8_t *; // uint8_t[0x18] + using PackedMcuVersion = uint32_t; + using PackedMomentProcessorConfig = uint8_t *; // uint8_t[0x20] + using PackedTeraPluginProcessorConfig = uint64_t; + + class IIrSensorServer; + class IIrSensorSystemServer; +} +namespace nn::lbl::detail { + class ILblController; +} +namespace nn::ldn::detail { + class IMonitorService; + class IMonitorServiceCreator; + class ISystemLocalCommunicationService; + class ISystemServiceCreator; + class IUserLocalCommunicationService; + class IUserServiceCreator; +} +namespace nn::lm { + class ILogService; + class ILogger; +} +namespace nn::mii { + using CharInfo = uint8_t *; // uint8_t[0x58] + using CharInfoElement = uint8_t; + using CreateId = uint128_t; + using StoreData = uint8_t *; // uint8_t[0x44] + using StoreDataElement = uint8_t; +} +namespace nn::mii::detail { + class IDatabaseService; + class IStaticService; +} +namespace nn::mmnv { + class IRequest; +} +namespace nn::ncm { + using ApplicationId = uint64_t; + using ProgramId = uint64_t; + using StorageId = uint8_t; + using SystemApplicationId = uint64_t; +} +namespace nn::ncm::detail { + class INcmInterface; + class INcmInterface4Unknown; + class INcmInterface5Unknown; + class LocationResolverInterface; +} +namespace nn::news::detail::ipc { + class INewlyArrivedEventHolder; + class INewsDataService; + class INewsDatabaseService; + class INewsService; + class IOverwriteEventHolder; + class IServiceCreator; +} +namespace nn::nfc::am::detail { + class IAm; + class IAmManager; +} +namespace nn::nfc::detail { + class ISystem; + class ISystemManager; + class IUser; + class IUserManager; +} +namespace nn::nfc::mifare::detail { + class IUser; + class IUserManager; +} +namespace nn::nfp::detail { + class IDebug; + class IDebugManager; + class ISystem; + class ISystemManager; + class IUser; + class IUserManager; +} +namespace nn::nifm { + using AdditionalInfo = uint8_t; + using ClientId = uint8_t; + using DnsSetting = uint8_t *; // uint8_t[9] + using IpAddressSetting = uint8_t *; // uint8_t[0xd] + using IpSettingData = uint8_t; + using IpV4Address = uint32_t; + using Requirement = uint8_t *; // uint8_t[0x24] + using SsidListVersion = uint128_t; + using TelemetryInfo = uint8_t; +} +namespace nn::nifm::detail { + class IGeneralService; + class INetworkProfile; + class IRequest; + class IScanRequest; + class IStaticService; +} +namespace nn::nifm::detail::sf { + using AccessPointData = uint8_t; + using InternetConnectionStatus = uint8_t *; // uint8_t[3] + using NetworkInterfaceInfo = uint8_t; + using NetworkProfileBasicInfo = uint8_t; + using NetworkProfileData = uint8_t; +} +namespace nn::nim::detail { + class IAsyncData; + class IAsyncProgressResult; + class IAsyncResult; + class IAsyncValue; + class INetworkInstallManager; + class IShopServiceManager; +} +namespace nn::npns { + using NotificationToken = uint8_t *; // uint8_t[0x28] + + class INpnsSystem; + class INpnsUser; + class Weird; +} +namespace nn::ns { + using ApplicationControlProperty = uint8_t; +} +namespace nn::ns::detail { + class IAccountProxyInterface; + class IApplicationManagerInterface; + class IAsyncResult; + class IAsyncValue; + class IContentManagementInterface; + class IDevelopInterface; + class IDocumentInterface; + class IDownloadTaskInterface; + class IFactoryResetInterface; + class IGameCardStopper; + class IProgressAsyncResult; + class IProgressMonitorForDeleteUserSaveDataAll; + class IRequestServerStopper; + class IServiceGetterInterface; + class ISystemUpdateControl; + class ISystemUpdateInterface; + class IVulnerabilityManagerInterface; +} +namespace nn::nsd::detail { + class IManager; +} +namespace nn::ntc::detail::service { + class IEnsureNetworkClockAvailabilityService; + class IStaticService; +} +namespace nn::oe { + using DisplayVersion = uint128_t; +} +namespace nn::omm::detail { + class IOperationModeManager; +} +namespace nn::ovln { + class IReceiver; + class IReceiverService; + class ISender; + class ISenderService; +} +namespace nn::pcie::detail { + class IManager; + class ISession; +} +namespace nn::pctl { + using FreeCommunicationApplicationInfo = uint8_t; + using InquiryCode = uint8_t *; // uint8_t[0x20] + using PlayTimerSettings = uint8_t *; // uint8_t[0x34] + using SafetyLevelSettings = uint8_t *; // uint8_t[3] +} +namespace nn::pctl::detail { + using AsyncData = uint64_t; + using PairingAccountInfoBase = uint128_t; + using PairingInfoBase = uint128_t; +} +namespace nn::pctl::detail::ipc { + class IParentalControlService; + class IParentalControlServiceFactory; +} +namespace nn::pcv { + using ModuleState = uint8_t *; // uint8_t[0xc] + using PowerControlTarget = uint32_t; + using PowerDomainState = uint8_t; + using TemperatureThreshold = uint8_t; + + class IArbitrationManager; + class IImmediateManager; +} +namespace nn::pcv::detail { + class IPcvService; +} +namespace nn::pdm::detail { + class INotifyService; + class IQueryService; +} +namespace nn::pinmux { + class IManager; + class ISession; +} +namespace nn::pl::detail { + class ISharedFontManager; +} +namespace nn::prepo::detail::ipc { + class IPrepoService; +} +namespace nn::psc::sf { + class IPmControl; + class IPmModule; + class IPmService; +} +namespace nn::psm { + class IPsmServer; + class IPsmSession; +} +namespace nn::pwm { + class IChannelSession; + class IManager; +} +namespace nn::ro::detail { + class IDebugMonitorInterface; + class ILdrShellInterface; + class IRoInterface; +} +namespace nn::sasbus { + class IManager; + class ISession; +} +namespace nn::settings { + using LanguageCode = uint64_t; + using SettingsItemKey = uint8_t; + using SettingsName = uint8_t; + + class IFactorySettingsServer; + class IFirmwareDebugSettingsServer; + class ISettingsItemKeyIterator; + class ISettingsServer; + class ISystemSettingsServer; +} +namespace nn::settings::factory { + using AccelerometerOffset = uint8_t *; // uint8_t[6] + using AccelerometerScale = uint8_t *; // uint8_t[6] + using BatteryLot = uint8_t *; // uint8_t[0x18] + using BdAddress = uint8_t *; // uint8_t[6] + using ConfigurationId1 = uint8_t *; // uint8_t[0x1e] + using CountryCode = uint8_t; + using EccB233DeviceCertificate = uint8_t; + using EccB233DeviceKey = uint8_t *; // uint8_t[0x54] + using GameCardCertificate = uint8_t; + using GameCardKey = uint8_t; + using GyroscopeOffset = uint8_t *; // uint8_t[6] + using GyroscopeScale = uint8_t *; // uint8_t[6] + using MacAddress = uint8_t *; // uint8_t[6] + using Rsa2048DeviceCertificate = uint8_t; + using Rsa2048DeviceKey = uint8_t; + using SerialNumber = uint8_t *; // uint8_t[0x18] + using SpeakerParameter = uint8_t *; // uint8_t[0x5a] + using SslCertificate = uint8_t; + using SslKey = uint8_t; +} +namespace nn::settings::system { + using AccountNotificationSettings = uint8_t; + using AccountSettings = uint32_t; + using AudioVolume = uint64_t; + using BacklightSettings = uint8_t *; // uint8_t[0x28] + using BacklightSettingsEx = uint8_t *; // uint8_t[0x2c] + using BatteryLot = uint8_t *; // uint8_t[0x18] + using BluetoothDevicesSettings = uint8_t; + using DataDeletionSettings = uint64_t; + using DeviceNickName = uint8_t; + using Edid = uint8_t; + using EulaVersion = uint8_t; + using FatalDirtyFlag = uint128_t; + using FirmwareVersion = uint8_t; + using InitialLaunchSettings = uint8_t *; // uint8_t[0x20] + using NetworkSettings = uint8_t; + using NotificationSettings = uint8_t *; // uint8_t[0x18] + using NxControllerSettings = uint8_t; + using PtmFuelGaugeParameter = uint8_t *; // uint8_t[0x18] + using SerialNumber = uint8_t *; // uint8_t[0x18] + using SleepSettings = uint8_t *; // uint8_t[0xc] + using TelemetryDirtyFlag = uint128_t; + using TvSettings = uint8_t *; // uint8_t[0x20] +} +namespace nn::sm::detail { + class IManagerInterface; + class IUserInterface; +} +namespace nn::socket::resolver { + class IResolver; +} +namespace nn::socket::sf { + class IClient; +} +namespace nn::spl::detail { + class IRandomInterface; +} +namespace nn::spsm::detail { + class IPowerStateInterface; +} +namespace nn::ssl::sf { + using CertificateFormat = uint32_t; + using ContextOption = uint32_t; + using InternalPki = uint32_t; + using IoMode = uint32_t; + using OptionType = uint32_t; + using PollEvent = uint32_t; + using RenegotiationMode = uint32_t; + using SessionCacheMode = uint32_t; + using SslVersion = uint32_t; + using VerifyOption = uint32_t; + + class ISslConnection; + class ISslContext; + class ISslService; +} +namespace nn::tc { + class IManager; +} +namespace nn::time { + using CalendarTime = uint64_t; + using LocationName = uint8_t *; // uint8_t[0x24] + using PosixTime = uint64_t; + using SteadyClockTimePoint = uint8_t *; // uint8_t[0x18] + using SystemClockContext = uint8_t *; // uint8_t[0x20] + using TimeZoneRule = uint8_t; + using TimeZoneRuleVersion = uint128_t; +} +namespace nn::time::sf { + using CalendarAdditionalInfo = uint8_t *; // uint8_t[0x18] +} +namespace nn::timesrv::detail::service { + class IStaticService; + class ISteadyClock; + class ISystemClock; + class ITimeZoneService; +} +namespace nn::tma { + class IHtcManager; + class IHtcsManager; + class ISocket; +} +namespace nn::ts::server { + class IMeasurementServer; +} +namespace nn::uart { + class IManager; + class IPortSession; +} +namespace nn::usb::ds { + class IDsEndpoint; + class IDsInterface; + class IDsService; +} +namespace nn::usb::hs { + class IClientEpSession; + class IClientIfSession; + class IClientRootSession; +} +namespace nn::usb::pd::detail { + class IPdCradleManager; + class IPdCradleSession; + class IPdManager; + class IPdSession; +} +namespace nn::usb::pm { + class IPmService; +} +namespace nn::util { + using Unorm8x4 = uint32_t; + using Uuid = uint128_t; +} +namespace nn::vi { + using DisplayInfo = uint8_t; + using DisplayModeInfo = uint128_t; + using DisplayName = uint8_t *; // uint8_t[0x40] + using ProxyName = uint64_t; +} +namespace nn::visrv::sf { + class IApplicationDisplayService; + class IApplicationRootService; + class IManagerDisplayService; + class IManagerRootService; + class ISystemDisplayService; + class ISystemRootService; +} +namespace nn::wlan::detail { + class IInfraManager; + class ILocalGetActionFrame; + class ILocalGetFrame; + class ILocalManager; + class ISocketGetFrame; + class ISocketManager; +} +namespace nn::xcd::detail { + class ISystemServer; +} +namespace nns::hosbinder { + class IHOSBinderDriver; +} +namespace nns::nvdrv { + class INvDrvDebugFSServices; + class INvDrvServices; +} +namespace nv::gemcontrol { + class INvGemControl; +} +namespace nv::gemcoredump { + class INvGemCoreDump; +} + +//// namespace None { + class SmService { + public: + SmService(); + uint32_t GetService(IN ServiceName name, OUT IPipe * _1); + uint32_t Initialize(); + uint32_t RegisterService(IN ServiceName name, OUT NPort * _1); + uint32_t UnregisterService(IN ServiceName name); + }; +//// } +#ifdef DEFINE_CALLERS +uint32_t SmService::GetService(IN ServiceName name, OUT IPipe * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new IPipe(resp.move_handles[0]); + return ret; +} +uint32_t SmService::Initialize() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t SmService::RegisterService(IN ServiceName name, OUT NPort * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new NPort(resp.move_handles[0]); + return ret; +} +uint32_t SmService::UnregisterService(IN ServiceName name) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace Pm { + class Bm { + public: + Bm(); + uint32_t EnableMaintenanceMode(); + uint32_t Init(OUT uint64_t& _0); + }; + class Shell { + public: + Shell(); + uint32_t GetProcessEventWaiter(OUT KObject * _0); + uint32_t LaunchTitle(IN uint64_t _0, IN nn::ApplicationId tid); + }; +} +#ifdef DEFINE_CALLERS +uint32_t Pm::Bm::EnableMaintenanceMode() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t Pm::Bm::Init(OUT uint64_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t Pm::Shell::GetProcessEventWaiter(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t Pm::Shell::LaunchTitle(IN uint64_t _0, IN nn::ApplicationId tid) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::account { + class IAccountServiceForAdministrator { + public: + IAccountServiceForAdministrator(); + uint32_t AuthenticateServiceAsync(OUT nn::account::detail::IAsyncContext * _0); + uint32_t BeginUserRegistration(OUT nn::account::Uid& _0); + uint32_t CancelUserRegistration(IN nn::account::Uid _0); + uint32_t ClearSaveDataThumbnail(IN nn::account::Uid _0, IN nn::ApplicationId _1); + uint32_t CompleteUserRegistration(IN nn::account::Uid _0); + uint32_t CompleteUserRegistrationForcibly(IN nn::account::Uid _0); + uint32_t CreateFloatingRegistrationRequest(IN uint32_t _0, IN KObject * _1, OUT nn::account::baas::IFloatingRegistrationRequest * _2); + uint32_t DebugInvalidateTokenCacheForUser(IN nn::account::Uid _0); + uint32_t DebugSetUserStateClose(IN nn::account::Uid _0); + uint32_t DebugSetUserStateOpen(IN nn::account::Uid _0); + uint32_t DeleteUser(IN nn::account::Uid _0); + uint32_t GetBaasAccountAdministrator(IN nn::account::Uid _0, OUT nn::account::baas::IAdministrator * _1); + uint32_t GetBaasAccountManagerForSystemService(IN nn::account::Uid _0, OUT nn::account::baas::IManagerForSystemService * _1); + uint32_t GetBaasUserAvailabilityChangeNotifier(OUT nn::account::detail::INotifier * _0); + uint32_t GetLastOpenedUser(OUT nn::account::Uid& _0); + uint32_t GetProfile(IN nn::account::Uid _0, OUT nn::account::profile::IProfile * _1); + uint32_t GetProfileDigest(IN nn::account::Uid _0, OUT nn::account::ProfileDigest& _1); + uint32_t GetProfileEditor(IN nn::account::Uid _0, OUT nn::account::profile::IProfileEditor * _1); + uint32_t GetProfileUpdateNotifier(OUT nn::account::detail::INotifier * _0); + uint32_t GetUserCount(OUT int32_t& _0); + uint32_t GetUserExistence(IN nn::account::Uid _0, OUT bool& _1); + uint32_t GetUserLastOpenedApplication(IN nn::account::Uid _0, OUT uint32_t& _1, OUT nn::ApplicationId& _2); + uint32_t GetUserRegistrationNotifier(OUT nn::account::detail::INotifier * _0); + uint32_t GetUserStateChangeNotifier(OUT nn::account::detail::INotifier * _0); + uint32_t IsUserRegistrationRequestPermitted(IN uint64_t _0, IN gpid _1, OUT bool& _2); + uint32_t ListAllUsers(OUT nn::account::Uid * _0, guint _0_size); + uint32_t ListOpenUsers(OUT nn::account::Uid * _0, guint _0_size); + uint32_t LoadSaveDataThumbnail(IN nn::account::Uid _0, IN nn::ApplicationId _1, OUT uint32_t& _2, OUT uint8_t * _3, guint _3_size); + uint32_t ProxyProcedureForFloatingRegistrationWithNintendoAccount(IN nn::account::detail::Uuid _0, OUT nn::account::nas::IOAuthProcedureForExternalNsa * _1); + uint32_t ProxyProcedureForGuestLoginWithNintendoAccount(IN nn::account::detail::Uuid _0, OUT nn::account::nas::IOAuthProcedureForExternalNsa * _1); + uint32_t SetUserPosition(IN int32_t _0, IN nn::account::Uid _1); + uint32_t StoreSaveDataThumbnail(IN nn::account::Uid _0, IN nn::ApplicationId _1, IN uint8_t * _2, guint _2_size); + uint32_t SuspendBackgroundDaemon(OUT nn::account::detail::ISessionObject * _0); + uint32_t TrySelectUserWithoutInteraction(IN bool _0, OUT nn::account::Uid& _1); + }; + class IAccountServiceForApplication { + public: + IAccountServiceForApplication(); + uint32_t AuthenticateApplicationAsync(OUT nn::account::detail::IAsyncContext * _0); + uint32_t ClearSaveDataThumbnail(IN nn::account::Uid _0); + uint32_t CreateGuestLoginRequest(IN uint32_t _0, IN KObject * _1, OUT nn::account::baas::IGuestLoginRequest * _2); + uint32_t GetBaasAccountManagerForApplication(IN nn::account::Uid _0, OUT nn::account::baas::IManagerForApplication * _1); + uint32_t GetLastOpenedUser(OUT nn::account::Uid& _0); + uint32_t GetProfile(IN nn::account::Uid _0, OUT nn::account::profile::IProfile * _1); + uint32_t GetProfileDigest(IN nn::account::Uid _0, OUT nn::account::ProfileDigest& _1); + uint32_t GetUserCount(OUT int32_t& _0); + uint32_t GetUserExistence(IN nn::account::Uid _0, OUT bool& _1); + uint32_t InitializeApplicationInfo(IN uint64_t _0, IN gpid _1); + uint32_t IsUserRegistrationRequestPermitted(IN uint64_t _0, IN gpid _1, OUT bool& _2); + uint32_t ListAllUsers(OUT nn::account::Uid * _0, guint _0_size); + uint32_t ListOpenUsers(OUT nn::account::Uid * _0, guint _0_size); + uint32_t StoreSaveDataThumbnail(IN nn::account::Uid _0, IN uint8_t * _1, guint _1_size); + uint32_t TrySelectUserWithoutInteraction(IN bool _0, OUT nn::account::Uid& _1); + }; + class IAccountServiceForSystemService { + public: + IAccountServiceForSystemService(); + uint32_t ClearSaveDataThumbnail(IN nn::account::Uid _0, IN nn::ApplicationId _1); + uint32_t DebugInvalidateTokenCacheForUser(IN nn::account::Uid _0); + uint32_t DebugSetUserStateClose(IN nn::account::Uid _0); + uint32_t DebugSetUserStateOpen(IN nn::account::Uid _0); + uint32_t GetBaasAccountManagerForSystemService(IN nn::account::Uid _0, OUT nn::account::baas::IManagerForSystemService * _1); + uint32_t GetBaasUserAvailabilityChangeNotifier(OUT nn::account::detail::INotifier * _0); + uint32_t GetLastOpenedUser(OUT nn::account::Uid& _0); + uint32_t GetProfile(IN nn::account::Uid _0, OUT nn::account::profile::IProfile * _1); + uint32_t GetProfileDigest(IN nn::account::Uid _0, OUT nn::account::ProfileDigest& _1); + uint32_t GetProfileUpdateNotifier(OUT nn::account::detail::INotifier * _0); + uint32_t GetUserCount(OUT int32_t& _0); + uint32_t GetUserExistence(IN nn::account::Uid _0, OUT bool& _1); + uint32_t GetUserLastOpenedApplication(IN nn::account::Uid _0, OUT uint32_t& _1, OUT nn::ApplicationId& _2); + uint32_t GetUserRegistrationNotifier(OUT nn::account::detail::INotifier * _0); + uint32_t GetUserStateChangeNotifier(OUT nn::account::detail::INotifier * _0); + uint32_t IsUserRegistrationRequestPermitted(IN uint64_t _0, IN gpid _1, OUT bool& _2); + uint32_t ListAllUsers(OUT nn::account::Uid * _0, guint _0_size); + uint32_t ListOpenUsers(OUT nn::account::Uid * _0, guint _0_size); + uint32_t LoadSaveDataThumbnail(IN nn::account::Uid _0, IN nn::ApplicationId _1, OUT uint32_t& _2, OUT uint8_t * _3, guint _3_size); + uint32_t StoreSaveDataThumbnail(IN nn::account::Uid _0, IN nn::ApplicationId _1, IN uint8_t * _2, guint _2_size); + uint32_t TrySelectUserWithoutInteraction(IN bool _0, OUT nn::account::Uid& _1); + }; + class IBaasAccessTokenAccessor { + public: + IBaasAccessTokenAccessor(); + uint32_t EnsureCacheAsync(IN nn::account::Uid _0, OUT nn::account::detail::IAsyncContext * _1); + uint32_t GetDeviceAccountId(IN nn::account::Uid _0, OUT uint64_t& _1); + uint32_t LoadCache(IN nn::account::Uid _0, OUT uint32_t& _1, OUT uint8_t * _2, guint _2_size); + uint32_t RegisterNotificationTokenAsync(IN nn::npns::NotificationToken _0, IN nn::account::Uid _1, OUT nn::account::detail::IAsyncContext * _2); + uint32_t UnregisterNotificationTokenAsync(IN nn::account::Uid _0, OUT nn::account::detail::IAsyncContext * _1); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::account::IAccountServiceForAdministrator::AuthenticateServiceAsync(OUT nn::account::detail::IAsyncContext * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::account::detail::IAsyncContext(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::IAccountServiceForAdministrator::BeginUserRegistration(OUT nn::account::Uid& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::IAccountServiceForAdministrator::CancelUserRegistration(IN nn::account::Uid _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::IAccountServiceForAdministrator::ClearSaveDataThumbnail(IN nn::account::Uid _0, IN nn::ApplicationId _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::IAccountServiceForAdministrator::CompleteUserRegistration(IN nn::account::Uid _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::IAccountServiceForAdministrator::CompleteUserRegistrationForcibly(IN nn::account::Uid _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::IAccountServiceForAdministrator::CreateFloatingRegistrationRequest(IN uint32_t _0, IN KObject * _1, OUT nn::account::baas::IFloatingRegistrationRequest * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _2 OMG = new nn::account::baas::IFloatingRegistrationRequest(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::IAccountServiceForAdministrator::DebugInvalidateTokenCacheForUser(IN nn::account::Uid _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::IAccountServiceForAdministrator::DebugSetUserStateClose(IN nn::account::Uid _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::IAccountServiceForAdministrator::DebugSetUserStateOpen(IN nn::account::Uid _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::IAccountServiceForAdministrator::DeleteUser(IN nn::account::Uid _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::IAccountServiceForAdministrator::GetBaasAccountAdministrator(IN nn::account::Uid _0, OUT nn::account::baas::IAdministrator * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new nn::account::baas::IAdministrator(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::IAccountServiceForAdministrator::GetBaasAccountManagerForSystemService(IN nn::account::Uid _0, OUT nn::account::baas::IManagerForSystemService * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new nn::account::baas::IManagerForSystemService(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::IAccountServiceForAdministrator::GetBaasUserAvailabilityChangeNotifier(OUT nn::account::detail::INotifier * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::account::detail::INotifier(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::IAccountServiceForAdministrator::GetLastOpenedUser(OUT nn::account::Uid& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::IAccountServiceForAdministrator::GetProfile(IN nn::account::Uid _0, OUT nn::account::profile::IProfile * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new nn::account::profile::IProfile(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::IAccountServiceForAdministrator::GetProfileDigest(IN nn::account::Uid _0, OUT nn::account::ProfileDigest& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::IAccountServiceForAdministrator::GetProfileEditor(IN nn::account::Uid _0, OUT nn::account::profile::IProfileEditor * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new nn::account::profile::IProfileEditor(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::IAccountServiceForAdministrator::GetProfileUpdateNotifier(OUT nn::account::detail::INotifier * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::account::detail::INotifier(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::IAccountServiceForAdministrator::GetUserCount(OUT int32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::IAccountServiceForAdministrator::GetUserExistence(IN nn::account::Uid _0, OUT bool& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::IAccountServiceForAdministrator::GetUserLastOpenedApplication(IN nn::account::Uid _0, OUT uint32_t& _1, OUT nn::ApplicationId& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::IAccountServiceForAdministrator::GetUserRegistrationNotifier(OUT nn::account::detail::INotifier * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::account::detail::INotifier(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::IAccountServiceForAdministrator::GetUserStateChangeNotifier(OUT nn::account::detail::INotifier * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::account::detail::INotifier(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::IAccountServiceForAdministrator::IsUserRegistrationRequestPermitted(IN uint64_t _0, IN gpid _1, OUT bool& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::IAccountServiceForAdministrator::ListAllUsers(OUT nn::account::Uid * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0xa, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::account::IAccountServiceForAdministrator::ListOpenUsers(OUT nn::account::Uid * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0xa, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::account::IAccountServiceForAdministrator::LoadSaveDataThumbnail(IN nn::account::Uid _0, IN nn::ApplicationId _1, OUT uint32_t& _2, OUT uint8_t * _3, guint _3_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::account::IAccountServiceForAdministrator::ProxyProcedureForFloatingRegistrationWithNintendoAccount(IN nn::account::detail::Uuid _0, OUT nn::account::nas::IOAuthProcedureForExternalNsa * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new nn::account::nas::IOAuthProcedureForExternalNsa(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::IAccountServiceForAdministrator::ProxyProcedureForGuestLoginWithNintendoAccount(IN nn::account::detail::Uuid _0, OUT nn::account::nas::IOAuthProcedureForExternalNsa * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new nn::account::nas::IOAuthProcedureForExternalNsa(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::IAccountServiceForAdministrator::SetUserPosition(IN int32_t _0, IN nn::account::Uid _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::IAccountServiceForAdministrator::StoreSaveDataThumbnail(IN nn::account::Uid _0, IN nn::ApplicationId _1, IN uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::account::IAccountServiceForAdministrator::SuspendBackgroundDaemon(OUT nn::account::detail::ISessionObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::account::detail::ISessionObject(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::IAccountServiceForAdministrator::TrySelectUserWithoutInteraction(IN bool _0, OUT nn::account::Uid& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::IAccountServiceForApplication::AuthenticateApplicationAsync(OUT nn::account::detail::IAsyncContext * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::account::detail::IAsyncContext(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::IAccountServiceForApplication::ClearSaveDataThumbnail(IN nn::account::Uid _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::IAccountServiceForApplication::CreateGuestLoginRequest(IN uint32_t _0, IN KObject * _1, OUT nn::account::baas::IGuestLoginRequest * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _2 OMG = new nn::account::baas::IGuestLoginRequest(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::IAccountServiceForApplication::GetBaasAccountManagerForApplication(IN nn::account::Uid _0, OUT nn::account::baas::IManagerForApplication * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new nn::account::baas::IManagerForApplication(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::IAccountServiceForApplication::GetLastOpenedUser(OUT nn::account::Uid& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::IAccountServiceForApplication::GetProfile(IN nn::account::Uid _0, OUT nn::account::profile::IProfile * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new nn::account::profile::IProfile(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::IAccountServiceForApplication::GetProfileDigest(IN nn::account::Uid _0, OUT nn::account::ProfileDigest& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::IAccountServiceForApplication::GetUserCount(OUT int32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::IAccountServiceForApplication::GetUserExistence(IN nn::account::Uid _0, OUT bool& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::IAccountServiceForApplication::InitializeApplicationInfo(IN uint64_t _0, IN gpid _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::IAccountServiceForApplication::IsUserRegistrationRequestPermitted(IN uint64_t _0, IN gpid _1, OUT bool& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::IAccountServiceForApplication::ListAllUsers(OUT nn::account::Uid * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0xa, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::account::IAccountServiceForApplication::ListOpenUsers(OUT nn::account::Uid * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0xa, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::account::IAccountServiceForApplication::StoreSaveDataThumbnail(IN nn::account::Uid _0, IN uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::account::IAccountServiceForApplication::TrySelectUserWithoutInteraction(IN bool _0, OUT nn::account::Uid& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::IAccountServiceForSystemService::ClearSaveDataThumbnail(IN nn::account::Uid _0, IN nn::ApplicationId _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::IAccountServiceForSystemService::DebugInvalidateTokenCacheForUser(IN nn::account::Uid _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::IAccountServiceForSystemService::DebugSetUserStateClose(IN nn::account::Uid _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::IAccountServiceForSystemService::DebugSetUserStateOpen(IN nn::account::Uid _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::IAccountServiceForSystemService::GetBaasAccountManagerForSystemService(IN nn::account::Uid _0, OUT nn::account::baas::IManagerForSystemService * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new nn::account::baas::IManagerForSystemService(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::IAccountServiceForSystemService::GetBaasUserAvailabilityChangeNotifier(OUT nn::account::detail::INotifier * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::account::detail::INotifier(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::IAccountServiceForSystemService::GetLastOpenedUser(OUT nn::account::Uid& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::IAccountServiceForSystemService::GetProfile(IN nn::account::Uid _0, OUT nn::account::profile::IProfile * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new nn::account::profile::IProfile(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::IAccountServiceForSystemService::GetProfileDigest(IN nn::account::Uid _0, OUT nn::account::ProfileDigest& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::IAccountServiceForSystemService::GetProfileUpdateNotifier(OUT nn::account::detail::INotifier * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::account::detail::INotifier(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::IAccountServiceForSystemService::GetUserCount(OUT int32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::IAccountServiceForSystemService::GetUserExistence(IN nn::account::Uid _0, OUT bool& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::IAccountServiceForSystemService::GetUserLastOpenedApplication(IN nn::account::Uid _0, OUT uint32_t& _1, OUT nn::ApplicationId& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::IAccountServiceForSystemService::GetUserRegistrationNotifier(OUT nn::account::detail::INotifier * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::account::detail::INotifier(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::IAccountServiceForSystemService::GetUserStateChangeNotifier(OUT nn::account::detail::INotifier * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::account::detail::INotifier(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::IAccountServiceForSystemService::IsUserRegistrationRequestPermitted(IN uint64_t _0, IN gpid _1, OUT bool& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::IAccountServiceForSystemService::ListAllUsers(OUT nn::account::Uid * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0xa, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::account::IAccountServiceForSystemService::ListOpenUsers(OUT nn::account::Uid * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0xa, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::account::IAccountServiceForSystemService::LoadSaveDataThumbnail(IN nn::account::Uid _0, IN nn::ApplicationId _1, OUT uint32_t& _2, OUT uint8_t * _3, guint _3_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::account::IAccountServiceForSystemService::StoreSaveDataThumbnail(IN nn::account::Uid _0, IN nn::ApplicationId _1, IN uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::account::IAccountServiceForSystemService::TrySelectUserWithoutInteraction(IN bool _0, OUT nn::account::Uid& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::IBaasAccessTokenAccessor::EnsureCacheAsync(IN nn::account::Uid _0, OUT nn::account::detail::IAsyncContext * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new nn::account::detail::IAsyncContext(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::IBaasAccessTokenAccessor::GetDeviceAccountId(IN nn::account::Uid _0, OUT uint64_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::IBaasAccessTokenAccessor::LoadCache(IN nn::account::Uid _0, OUT uint32_t& _1, OUT uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::account::IBaasAccessTokenAccessor::RegisterNotificationTokenAsync(IN nn::npns::NotificationToken _0, IN nn::account::Uid _1, OUT nn::account::detail::IAsyncContext * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _2 OMG = new nn::account::detail::IAsyncContext(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::IBaasAccessTokenAccessor::UnregisterNotificationTokenAsync(IN nn::account::Uid _0, OUT nn::account::detail::IAsyncContext * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new nn::account::detail::IAsyncContext(resp.move_handles[0]); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::account::baas { + class IAdministrator { + public: + IAdministrator(); + uint32_t CheckAvailability(); + uint32_t CreateAuthorizationRequest(IN uint32_t _0, IN KObject * _1, IN nn::account::nas::NasClientInfo * _2, guint _2_size, IN nn::account::NintendoAccountAuthorizationRequestParameters * _3, guint _3_size, OUT nn::account::nas::IAuthorizationRequest * _4); + uint32_t CreateProcedureToLinkNnidWithNintendoAccount(OUT nn::account::http::IOAuthProcedure * _0); + uint32_t CreateProcedureToLinkWithNintendoAccount(OUT nn::account::nas::IOAuthProcedureForNintendoAccountLinkage * _0); + uint32_t CreateProcedureToUpdateLinkageStateOfNintendoAccount(OUT nn::account::http::IOAuthProcedure * _0); + uint32_t DebugSetAvailabilityErrorDetail(IN uint32_t _0); + uint32_t DebugUnlinkNintendoAccountAsync(OUT nn::account::detail::IAsyncContext * _0); + uint32_t DeleteRegistrationInfoLocally(); + uint32_t EnsureIdTokenCacheAsync(OUT nn::account::detail::IAsyncContext * _0); + uint32_t GetAccountId(OUT nn::account::NetworkServiceAccountId& _0); + uint32_t GetNintendoAccountId(OUT nn::account::NintendoAccountId& _0); + uint32_t GetNintendoAccountUserResourceCache(OUT nn::account::NintendoAccountId& _0, OUT nn::account::nas::NasUserBase * _1, guint _1_size, OUT uint8_t * _2, guint _2_size); + uint32_t IsLinkedWithNintendoAccount(OUT bool& _0); + uint32_t IsRegistered(OUT bool& _0); + uint32_t LoadIdTokenCache(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size); + uint32_t ProxyProcedureToAcquireApplicationAuthorizationForNintendoAccount(IN nn::account::detail::Uuid _0, OUT nn::account::http::IOAuthProcedure * _1); + uint32_t RefreshNintendoAccountUserResourceCacheAsync(OUT nn::account::detail::IAsyncContext * _0); + uint32_t RefreshNintendoAccountUserResourceCacheAsyncIfSecondsElapsed(IN uint32_t _0, OUT bool& _1, OUT nn::account::detail::IAsyncContext * _2); + uint32_t RegisterAsync(OUT nn::account::detail::IAsyncContext * _0); + uint32_t ResumeProcedureToLinkNnidWithNintendoAccount(IN nn::account::detail::Uuid _0, OUT nn::account::http::IOAuthProcedure * _1); + uint32_t ResumeProcedureToLinkWithNintendoAccount(IN nn::account::detail::Uuid _0, OUT nn::account::nas::IOAuthProcedureForNintendoAccountLinkage * _1); + uint32_t ResumeProcedureToUpdateLinkageStateOfNintendoAccount(IN nn::account::detail::Uuid _0, OUT nn::account::http::IOAuthProcedure * _1); + uint32_t SetSystemProgramIdentification(IN uint64_t _0, IN gpid _1, IN nn::account::SystemProgramIdentification * _2, guint _2_size); + uint32_t SynchronizeProfileAsync(OUT nn::account::detail::IAsyncContext * _0); + uint32_t SynchronizeProfileAsyncIfSecondsElapsed(IN uint32_t _0, OUT bool& _1, OUT nn::account::detail::IAsyncContext * _2); + uint32_t UnregisterAsync(OUT nn::account::detail::IAsyncContext * _0); + uint32_t UploadProfileAsync(OUT nn::account::detail::IAsyncContext * _0); + }; + class IFloatingRegistrationRequest { + public: + IFloatingRegistrationRequest(); + uint32_t EnsureIdTokenCacheAsync(OUT nn::account::detail::IAsyncContext * _0); + uint32_t GetAccountId(OUT nn::account::NetworkServiceAccountId& _0); + uint32_t GetLinkedNintendoAccountId(OUT nn::account::NintendoAccountId& _0); + uint32_t GetNickname(OUT int8_t * _0, guint _0_size); + uint32_t GetProfileImage(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size); + uint32_t GetSessionId(OUT nn::account::detail::Uuid& _0); + uint32_t LoadIdTokenCache(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size); + uint32_t RegisterAsync(OUT nn::account::Uid& _0, OUT nn::account::detail::IAsyncContext * _1); + uint32_t RegisterWithUidAsync(IN nn::account::Uid _0, OUT nn::account::detail::IAsyncContext * _1); + uint32_t SetSystemProgramIdentification(IN uint64_t _0, IN gpid _1, IN nn::account::SystemProgramIdentification * _2, guint _2_size); + }; + class IGuestLoginRequest { + public: + IGuestLoginRequest(); + uint32_t GetAccountId(OUT nn::account::NetworkServiceAccountId& _0); + uint32_t GetLinkedNintendoAccountId(OUT nn::account::NintendoAccountId& _0); + uint32_t GetNickname(OUT int8_t * _0, guint _0_size); + uint32_t GetProfileImage(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size); + uint32_t GetSessionId(OUT nn::account::detail::Uuid& _0); + uint32_t LoadIdTokenCache(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size); + }; + class IManagerForApplication { + public: + IManagerForApplication(); + uint32_t CheckAvailability(); + uint32_t CreateAuthorizationRequest(IN uint32_t _0, IN KObject * _1, IN nn::account::NintendoAccountAuthorizationRequestParameters * _2, guint _2_size, OUT nn::account::nas::IAuthorizationRequest * _3); + uint32_t EnsureIdTokenCacheAsync(OUT nn::account::detail::IAsyncContext * _0); + uint32_t GetAccountId(OUT nn::account::NetworkServiceAccountId& _0); + uint32_t GetNintendoAccountUserResourceCacheForApplication(OUT nn::account::NintendoAccountId& _0, OUT nn::account::nas::NasUserBaseForApplication * _1, guint _1_size, OUT uint8_t * _2, guint _2_size); + uint32_t LoadIdTokenCache(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size); + }; + class IManagerForSystemService { + public: + IManagerForSystemService(); + uint32_t CheckAvailability(); + uint32_t CreateAuthorizationRequest(IN uint32_t _0, IN KObject * _1, IN nn::account::nas::NasClientInfo * _2, guint _2_size, IN nn::account::NintendoAccountAuthorizationRequestParameters * _3, guint _3_size, OUT nn::account::nas::IAuthorizationRequest * _4); + uint32_t EnsureIdTokenCacheAsync(OUT nn::account::detail::IAsyncContext * _0); + uint32_t GetAccountId(OUT nn::account::NetworkServiceAccountId& _0); + uint32_t GetNintendoAccountId(OUT nn::account::NintendoAccountId& _0); + uint32_t GetNintendoAccountUserResourceCache(OUT nn::account::NintendoAccountId& _0, OUT nn::account::nas::NasUserBase * _1, guint _1_size, OUT uint8_t * _2, guint _2_size); + uint32_t LoadIdTokenCache(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size); + uint32_t RefreshNintendoAccountUserResourceCacheAsync(OUT nn::account::detail::IAsyncContext * _0); + uint32_t RefreshNintendoAccountUserResourceCacheAsyncIfSecondsElapsed(IN uint32_t _0, OUT bool& _1, OUT nn::account::detail::IAsyncContext * _2); + uint32_t SetSystemProgramIdentification(IN uint64_t _0, IN gpid _1, IN nn::account::SystemProgramIdentification * _2, guint _2_size); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::account::baas::IAdministrator::CheckAvailability() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::baas::IAdministrator::CreateAuthorizationRequest(IN uint32_t _0, IN KObject * _1, IN nn::account::nas::NasClientInfo * _2, guint _2_size, IN nn::account::NintendoAccountAuthorizationRequestParameters * _3, guint _3_size, OUT nn::account::nas::IAuthorizationRequest * _4) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(0x19, 1, temp5); + ctu->cpu.readmem(temp4, temp6, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + delete[] temp6; + _4 OMG = new nn::account::nas::IAuthorizationRequest(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::baas::IAdministrator::CreateProcedureToLinkNnidWithNintendoAccount(OUT nn::account::http::IOAuthProcedure * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::account::http::IOAuthProcedure(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::baas::IAdministrator::CreateProcedureToLinkWithNintendoAccount(OUT nn::account::nas::IOAuthProcedureForNintendoAccountLinkage * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::account::nas::IOAuthProcedureForNintendoAccountLinkage(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::baas::IAdministrator::CreateProcedureToUpdateLinkageStateOfNintendoAccount(OUT nn::account::http::IOAuthProcedure * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::account::http::IOAuthProcedure(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::baas::IAdministrator::DebugSetAvailabilityErrorDetail(IN uint32_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::baas::IAdministrator::DebugUnlinkNintendoAccountAsync(OUT nn::account::detail::IAsyncContext * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::account::detail::IAsyncContext(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::baas::IAdministrator::DeleteRegistrationInfoLocally() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::baas::IAdministrator::EnsureIdTokenCacheAsync(OUT nn::account::detail::IAsyncContext * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::account::detail::IAsyncContext(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::baas::IAdministrator::GetAccountId(OUT nn::account::NetworkServiceAccountId& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::baas::IAdministrator::GetNintendoAccountId(OUT nn::account::NintendoAccountId& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::baas::IAdministrator::GetNintendoAccountUserResourceCache(OUT nn::account::NintendoAccountId& _0, OUT nn::account::nas::NasUserBase * _1, guint _1_size, OUT uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + guint temp5; + auto temp4 = req.getBuffer(6, 0, temp5); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +uint32_t nn::account::baas::IAdministrator::IsLinkedWithNintendoAccount(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::baas::IAdministrator::IsRegistered(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::baas::IAdministrator::LoadIdTokenCache(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::account::baas::IAdministrator::ProxyProcedureToAcquireApplicationAuthorizationForNintendoAccount(IN nn::account::detail::Uuid _0, OUT nn::account::http::IOAuthProcedure * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new nn::account::http::IOAuthProcedure(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::baas::IAdministrator::RefreshNintendoAccountUserResourceCacheAsync(OUT nn::account::detail::IAsyncContext * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::account::detail::IAsyncContext(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::baas::IAdministrator::RefreshNintendoAccountUserResourceCacheAsyncIfSecondsElapsed(IN uint32_t _0, OUT bool& _1, OUT nn::account::detail::IAsyncContext * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _2 OMG = new nn::account::detail::IAsyncContext(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::baas::IAdministrator::RegisterAsync(OUT nn::account::detail::IAsyncContext * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::account::detail::IAsyncContext(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::baas::IAdministrator::ResumeProcedureToLinkNnidWithNintendoAccount(IN nn::account::detail::Uuid _0, OUT nn::account::http::IOAuthProcedure * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new nn::account::http::IOAuthProcedure(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::baas::IAdministrator::ResumeProcedureToLinkWithNintendoAccount(IN nn::account::detail::Uuid _0, OUT nn::account::nas::IOAuthProcedureForNintendoAccountLinkage * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new nn::account::nas::IOAuthProcedureForNintendoAccountLinkage(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::baas::IAdministrator::ResumeProcedureToUpdateLinkageStateOfNintendoAccount(IN nn::account::detail::Uuid _0, OUT nn::account::http::IOAuthProcedure * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new nn::account::http::IOAuthProcedure(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::baas::IAdministrator::SetSystemProgramIdentification(IN uint64_t _0, IN gpid _1, IN nn::account::SystemProgramIdentification * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::account::baas::IAdministrator::SynchronizeProfileAsync(OUT nn::account::detail::IAsyncContext * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::account::detail::IAsyncContext(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::baas::IAdministrator::SynchronizeProfileAsyncIfSecondsElapsed(IN uint32_t _0, OUT bool& _1, OUT nn::account::detail::IAsyncContext * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _2 OMG = new nn::account::detail::IAsyncContext(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::baas::IAdministrator::UnregisterAsync(OUT nn::account::detail::IAsyncContext * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::account::detail::IAsyncContext(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::baas::IAdministrator::UploadProfileAsync(OUT nn::account::detail::IAsyncContext * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::account::detail::IAsyncContext(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::baas::IFloatingRegistrationRequest::EnsureIdTokenCacheAsync(OUT nn::account::detail::IAsyncContext * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::account::detail::IAsyncContext(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::baas::IFloatingRegistrationRequest::GetAccountId(OUT nn::account::NetworkServiceAccountId& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::baas::IFloatingRegistrationRequest::GetLinkedNintendoAccountId(OUT nn::account::NintendoAccountId& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::baas::IFloatingRegistrationRequest::GetNickname(OUT int8_t * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0xa, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::account::baas::IFloatingRegistrationRequest::GetProfileImage(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::account::baas::IFloatingRegistrationRequest::GetSessionId(OUT nn::account::detail::Uuid& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::baas::IFloatingRegistrationRequest::LoadIdTokenCache(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::account::baas::IFloatingRegistrationRequest::RegisterAsync(OUT nn::account::Uid& _0, OUT nn::account::detail::IAsyncContext * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new nn::account::detail::IAsyncContext(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::baas::IFloatingRegistrationRequest::RegisterWithUidAsync(IN nn::account::Uid _0, OUT nn::account::detail::IAsyncContext * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new nn::account::detail::IAsyncContext(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::baas::IFloatingRegistrationRequest::SetSystemProgramIdentification(IN uint64_t _0, IN gpid _1, IN nn::account::SystemProgramIdentification * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::account::baas::IGuestLoginRequest::GetAccountId(OUT nn::account::NetworkServiceAccountId& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::baas::IGuestLoginRequest::GetLinkedNintendoAccountId(OUT nn::account::NintendoAccountId& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::baas::IGuestLoginRequest::GetNickname(OUT int8_t * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0xa, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::account::baas::IGuestLoginRequest::GetProfileImage(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::account::baas::IGuestLoginRequest::GetSessionId(OUT nn::account::detail::Uuid& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::baas::IGuestLoginRequest::LoadIdTokenCache(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::account::baas::IManagerForApplication::CheckAvailability() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::baas::IManagerForApplication::CreateAuthorizationRequest(IN uint32_t _0, IN KObject * _1, IN nn::account::NintendoAccountAuthorizationRequestParameters * _2, guint _2_size, OUT nn::account::nas::IAuthorizationRequest * _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + _3 OMG = new nn::account::nas::IAuthorizationRequest(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::baas::IManagerForApplication::EnsureIdTokenCacheAsync(OUT nn::account::detail::IAsyncContext * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::account::detail::IAsyncContext(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::baas::IManagerForApplication::GetAccountId(OUT nn::account::NetworkServiceAccountId& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::baas::IManagerForApplication::GetNintendoAccountUserResourceCacheForApplication(OUT nn::account::NintendoAccountId& _0, OUT nn::account::nas::NasUserBaseForApplication * _1, guint _1_size, OUT uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + guint temp5; + auto temp4 = req.getBuffer(6, 0, temp5); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +uint32_t nn::account::baas::IManagerForApplication::LoadIdTokenCache(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::account::baas::IManagerForSystemService::CheckAvailability() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::baas::IManagerForSystemService::CreateAuthorizationRequest(IN uint32_t _0, IN KObject * _1, IN nn::account::nas::NasClientInfo * _2, guint _2_size, IN nn::account::NintendoAccountAuthorizationRequestParameters * _3, guint _3_size, OUT nn::account::nas::IAuthorizationRequest * _4) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(0x19, 1, temp5); + ctu->cpu.readmem(temp4, temp6, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + delete[] temp6; + _4 OMG = new nn::account::nas::IAuthorizationRequest(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::baas::IManagerForSystemService::EnsureIdTokenCacheAsync(OUT nn::account::detail::IAsyncContext * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::account::detail::IAsyncContext(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::baas::IManagerForSystemService::GetAccountId(OUT nn::account::NetworkServiceAccountId& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::baas::IManagerForSystemService::GetNintendoAccountId(OUT nn::account::NintendoAccountId& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::baas::IManagerForSystemService::GetNintendoAccountUserResourceCache(OUT nn::account::NintendoAccountId& _0, OUT nn::account::nas::NasUserBase * _1, guint _1_size, OUT uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + guint temp5; + auto temp4 = req.getBuffer(6, 0, temp5); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +uint32_t nn::account::baas::IManagerForSystemService::LoadIdTokenCache(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::account::baas::IManagerForSystemService::RefreshNintendoAccountUserResourceCacheAsync(OUT nn::account::detail::IAsyncContext * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::account::detail::IAsyncContext(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::baas::IManagerForSystemService::RefreshNintendoAccountUserResourceCacheAsyncIfSecondsElapsed(IN uint32_t _0, OUT bool& _1, OUT nn::account::detail::IAsyncContext * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _2 OMG = new nn::account::detail::IAsyncContext(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::baas::IManagerForSystemService::SetSystemProgramIdentification(IN uint64_t _0, IN gpid _1, IN nn::account::SystemProgramIdentification * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::account::detail { + class IAsyncContext { + public: + IAsyncContext(); + uint32_t Cancel(); + uint32_t GetResult(); + uint32_t GetSystemEvent(OUT KObject * _0); + uint32_t HasDone(OUT bool& _0); + }; + class INotifier { + public: + INotifier(); + uint32_t GetSystemEvent(OUT KObject * _0); + }; + class ISessionObject { + public: + ISessionObject(); + uint32_t Dummy(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::account::detail::IAsyncContext::Cancel() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::detail::IAsyncContext::GetResult() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::detail::IAsyncContext::GetSystemEvent(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::account::detail::IAsyncContext::HasDone(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::detail::INotifier::GetSystemEvent(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::account::detail::ISessionObject::Dummy() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::account::http { + class IOAuthProcedure { + public: + IOAuthProcedure(); + uint32_t ApplyResponse(IN int8_t * _0, guint _0_size); + uint32_t ApplyResponseAsync(IN int8_t * _0, guint _0_size, OUT nn::account::detail::IAsyncContext * _1); + uint32_t GetRequest(OUT nn::account::RequestUrl * _0, guint _0_size, OUT nn::account::CallbackUri * _1, guint _1_size); + uint32_t PrepareAsync(OUT nn::account::detail::IAsyncContext * _0); + uint32_t Suspend(OUT nn::account::detail::Uuid& _0); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::account::http::IOAuthProcedure::ApplyResponse(IN int8_t * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(9, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::account::http::IOAuthProcedure::ApplyResponseAsync(IN int8_t * _0, guint _0_size, OUT nn::account::detail::IAsyncContext * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(9, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + _1 OMG = new nn::account::detail::IAsyncContext(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::http::IOAuthProcedure::GetRequest(OUT nn::account::RequestUrl * _0, guint _0_size, OUT nn::account::CallbackUri * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + guint temp5; + auto temp4 = req.getBuffer(0x1a, 1, temp5); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +uint32_t nn::account::http::IOAuthProcedure::PrepareAsync(OUT nn::account::detail::IAsyncContext * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::account::detail::IAsyncContext(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::http::IOAuthProcedure::Suspend(OUT nn::account::detail::Uuid& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::account::nas { + class IAuthorizationRequest { + public: + IAuthorizationRequest(); + uint32_t GetAuthorizationCode(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size); + uint32_t GetIdToken(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size); + uint32_t GetSessionId(OUT nn::account::detail::Uuid& _0); + uint32_t GetState(OUT nn::account::nas::State * _0, guint _0_size); + uint32_t InvokeWithoutInteractionAsync(OUT nn::account::detail::IAsyncContext * _0); + uint32_t IsAuthorized(OUT bool& _0); + }; + class IOAuthProcedureForExternalNsa { + public: + IOAuthProcedureForExternalNsa(); + uint32_t ApplyResponse(IN int8_t * _0, guint _0_size); + uint32_t ApplyResponseAsync(IN int8_t * _0, guint _0_size, OUT nn::account::detail::IAsyncContext * _1); + uint32_t GetAccountId(OUT nn::account::NetworkServiceAccountId& _0); + uint32_t GetLinkedNintendoAccountId(OUT nn::account::NintendoAccountId& _0); + uint32_t GetNickname(OUT int8_t * _0, guint _0_size); + uint32_t GetProfileImage(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size); + uint32_t GetRequest(OUT nn::account::RequestUrl * _0, guint _0_size, OUT nn::account::CallbackUri * _1, guint _1_size); + uint32_t PrepareAsync(OUT nn::account::detail::IAsyncContext * _0); + uint32_t Suspend(OUT nn::account::detail::Uuid& _0); + }; + class IOAuthProcedureForNintendoAccountLinkage { + public: + IOAuthProcedureForNintendoAccountLinkage(); + uint32_t ApplyResponse(IN int8_t * _0, guint _0_size); + uint32_t ApplyResponseAsync(IN int8_t * _0, guint _0_size, OUT nn::account::detail::IAsyncContext * _1); + uint32_t GetRequest(OUT nn::account::RequestUrl * _0, guint _0_size, OUT nn::account::CallbackUri * _1, guint _1_size); + uint32_t GetRequestWithTheme(IN int32_t _0, OUT nn::account::RequestUrl * _1, guint _1_size, OUT nn::account::CallbackUri * _2, guint _2_size); + uint32_t GetUrlForIntroductionOfExtraMembership(OUT nn::account::RequestUrl * _0, guint _0_size); + uint32_t IsNetworkServiceAccountReplaced(OUT bool& _0); + uint32_t PrepareAsync(OUT nn::account::detail::IAsyncContext * _0); + uint32_t Suspend(OUT nn::account::detail::Uuid& _0); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::account::nas::IAuthorizationRequest::GetAuthorizationCode(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::account::nas::IAuthorizationRequest::GetIdToken(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::account::nas::IAuthorizationRequest::GetSessionId(OUT nn::account::detail::Uuid& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::nas::IAuthorizationRequest::GetState(OUT nn::account::nas::State * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::account::nas::IAuthorizationRequest::InvokeWithoutInteractionAsync(OUT nn::account::detail::IAsyncContext * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::account::detail::IAsyncContext(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::nas::IAuthorizationRequest::IsAuthorized(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::nas::IOAuthProcedureForExternalNsa::ApplyResponse(IN int8_t * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(9, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::account::nas::IOAuthProcedureForExternalNsa::ApplyResponseAsync(IN int8_t * _0, guint _0_size, OUT nn::account::detail::IAsyncContext * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(9, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + _1 OMG = new nn::account::detail::IAsyncContext(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::nas::IOAuthProcedureForExternalNsa::GetAccountId(OUT nn::account::NetworkServiceAccountId& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::nas::IOAuthProcedureForExternalNsa::GetLinkedNintendoAccountId(OUT nn::account::NintendoAccountId& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::nas::IOAuthProcedureForExternalNsa::GetNickname(OUT int8_t * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0xa, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::account::nas::IOAuthProcedureForExternalNsa::GetProfileImage(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::account::nas::IOAuthProcedureForExternalNsa::GetRequest(OUT nn::account::RequestUrl * _0, guint _0_size, OUT nn::account::CallbackUri * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + guint temp5; + auto temp4 = req.getBuffer(0x1a, 1, temp5); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +uint32_t nn::account::nas::IOAuthProcedureForExternalNsa::PrepareAsync(OUT nn::account::detail::IAsyncContext * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::account::detail::IAsyncContext(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::nas::IOAuthProcedureForExternalNsa::Suspend(OUT nn::account::detail::Uuid& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::nas::IOAuthProcedureForNintendoAccountLinkage::ApplyResponse(IN int8_t * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(9, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::account::nas::IOAuthProcedureForNintendoAccountLinkage::ApplyResponseAsync(IN int8_t * _0, guint _0_size, OUT nn::account::detail::IAsyncContext * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(9, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + _1 OMG = new nn::account::detail::IAsyncContext(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::nas::IOAuthProcedureForNintendoAccountLinkage::GetRequest(OUT nn::account::RequestUrl * _0, guint _0_size, OUT nn::account::CallbackUri * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + guint temp5; + auto temp4 = req.getBuffer(0x1a, 1, temp5); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +uint32_t nn::account::nas::IOAuthProcedureForNintendoAccountLinkage::GetRequestWithTheme(IN int32_t _0, OUT nn::account::RequestUrl * _1, guint _1_size, OUT nn::account::CallbackUri * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + guint temp5; + auto temp4 = req.getBuffer(0x1a, 1, temp5); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +uint32_t nn::account::nas::IOAuthProcedureForNintendoAccountLinkage::GetUrlForIntroductionOfExtraMembership(OUT nn::account::RequestUrl * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::account::nas::IOAuthProcedureForNintendoAccountLinkage::IsNetworkServiceAccountReplaced(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::nas::IOAuthProcedureForNintendoAccountLinkage::PrepareAsync(OUT nn::account::detail::IAsyncContext * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::account::detail::IAsyncContext(resp.move_handles[0]); + return ret; +} +uint32_t nn::account::nas::IOAuthProcedureForNintendoAccountLinkage::Suspend(OUT nn::account::detail::Uuid& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::account::profile { + class IProfile { + public: + IProfile(); + uint32_t Get(OUT nn::account::profile::ProfileBase& _0, OUT nn::account::profile::UserData * _1, guint _1_size); + uint32_t GetBase(OUT nn::account::profile::ProfileBase& _0); + uint32_t GetImageSize(OUT uint32_t& _0); + uint32_t LoadImage(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size); + }; + class IProfileEditor { + public: + IProfileEditor(); + uint32_t Get(OUT nn::account::profile::ProfileBase& _0, OUT nn::account::profile::UserData * _1, guint _1_size); + uint32_t GetBase(OUT nn::account::profile::ProfileBase& _0); + uint32_t GetImageSize(OUT uint32_t& _0); + uint32_t LoadImage(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size); + uint32_t Store(IN nn::account::profile::ProfileBase _0, IN nn::account::profile::UserData * _1, guint _1_size); + uint32_t StoreWithImage(IN nn::account::profile::ProfileBase _0, IN nn::account::profile::UserData * _1, guint _1_size, IN uint8_t * _2, guint _2_size); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::account::profile::IProfile::Get(OUT nn::account::profile::ProfileBase& _0, OUT nn::account::profile::UserData * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + guint temp3; + auto temp2 = req.getBuffer(0x1a, 0, temp3); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp2, temp4, temp3); + delete[] temp4; + return ret; +} +uint32_t nn::account::profile::IProfile::GetBase(OUT nn::account::profile::ProfileBase& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::profile::IProfile::GetImageSize(OUT uint32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::profile::IProfile::LoadImage(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::account::profile::IProfileEditor::Get(OUT nn::account::profile::ProfileBase& _0, OUT nn::account::profile::UserData * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + guint temp3; + auto temp2 = req.getBuffer(0x1a, 0, temp3); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp2, temp4, temp3); + delete[] temp4; + return ret; +} +uint32_t nn::account::profile::IProfileEditor::GetBase(OUT nn::account::profile::ProfileBase& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::profile::IProfileEditor::GetImageSize(OUT uint32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::account::profile::IProfileEditor::LoadImage(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::account::profile::IProfileEditor::Store(IN nn::account::profile::ProfileBase _0, IN nn::account::profile::UserData * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::account::profile::IProfileEditor::StoreWithImage(IN nn::account::profile::ProfileBase _0, IN nn::account::profile::UserData * _1, guint _1_size, IN uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(5, 0, temp5); + ctu->cpu.readmem(temp4, temp6, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + delete[] temp6; + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::ahid { + class ICtrlSession { + public: + ICtrlSession(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown10(); + uint32_t Unknown11(); + uint32_t Unknown12(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + uint32_t Unknown5(); + uint32_t Unknown6(); + uint32_t Unknown7(); + uint32_t Unknown8(); + uint32_t Unknown9(); + }; + class IReadSession { + public: + IReadSession(); + uint32_t Unknown0(); + }; + class IServerSession { + public: + IServerSession(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + uint32_t Unknown3(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::ahid::ICtrlSession::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ahid::ICtrlSession::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ahid::ICtrlSession::Unknown10() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ahid::ICtrlSession::Unknown11() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ahid::ICtrlSession::Unknown12() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ahid::ICtrlSession::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ahid::ICtrlSession::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ahid::ICtrlSession::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ahid::ICtrlSession::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ahid::ICtrlSession::Unknown6() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ahid::ICtrlSession::Unknown7() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ahid::ICtrlSession::Unknown8() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ahid::ICtrlSession::Unknown9() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ahid::IReadSession::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ahid::IServerSession::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ahid::IServerSession::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ahid::IServerSession::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ahid::IServerSession::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::ahid::hdr { + class ISession { + public: + ISession(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::ahid::hdr::ISession::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ahid::hdr::ISession::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ahid::hdr::ISession::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ahid::hdr::ISession::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ahid::hdr::ISession::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::am::service { + class IAllSystemAppletProxiesService { + public: + IAllSystemAppletProxiesService(); + uint32_t CreateSelfLibraryAppletCreatorForDevelop(IN uint64_t _0, IN gpid _1, OUT nn::am::service::ILibraryAppletCreator * _2); + uint32_t OpenLibraryAppletProxy(IN uint64_t _0, IN gpid _1, IN KObject * _2, IN nn::am::AppletAttribute * _3, guint _3_size, OUT nn::am::service::ILibraryAppletProxy * _4); + uint32_t OpenLibraryAppletProxyOld(IN uint64_t _0, IN gpid _1, IN KObject * _2, OUT nn::am::service::ILibraryAppletProxy * _3); + uint32_t OpenOverlayAppletProxy(IN uint64_t _0, IN gpid _1, IN KObject * _2, OUT nn::am::service::IOverlayAppletProxy * _3); + uint32_t OpenSystemAppletProxy(IN uint64_t _0, IN gpid _1, IN KObject * _2, OUT nn::am::service::ISystemAppletProxy * _3); + uint32_t OpenSystemApplicationProxy(IN uint64_t _0, IN gpid _1, IN KObject * _2, OUT nn::am::service::IApplicationProxy * _3); + }; + class IAppletAccessor { + public: + IAppletAccessor(); + uint32_t GetAppletStateChangedEvent(OUT KObject * _0); + uint32_t GetResult(); + uint32_t IsCompleted(OUT bool& _0); + uint32_t RequestExit(); + uint32_t Start(); + uint32_t Terminate(); + }; + class IApplicationAccessor { + public: + IApplicationAccessor(); + uint32_t AreAnyLibraryAppletsLeft(OUT bool& _0); + uint32_t GetAppletStateChangedEvent(OUT KObject * _0); + uint32_t GetApplicationControlProperty(OUT uint8_t * _0, guint _0_size); + uint32_t GetApplicationId(OUT nn::ncm::ApplicationId& _0); + uint32_t GetApplicationLaunchProperty(OUT uint8_t * _0, guint _0_size); + uint32_t GetCurrentLibraryApplet(OUT nn::am::service::IAppletAccessor * _0); + uint32_t GetResult(); + uint32_t IsCompleted(OUT bool& _0); + uint32_t PushLaunchParameter(IN uint32_t _0, IN nn::am::service::IStorage * _1); + uint32_t RequestExit(); + uint32_t RequestForApplicationToGetForeground(); + uint32_t Start(); + uint32_t Terminate(); + uint32_t TerminateAllLibraryApplets(); + }; + class IApplicationCreator { + public: + IApplicationCreator(); + uint32_t CreateApplication(IN nn::ncm::ApplicationId _0, OUT nn::am::service::IApplicationAccessor * _1); + uint32_t CreateSystemApplication(IN nn::ncm::SystemApplicationId _0, OUT nn::am::service::IApplicationAccessor * _1); + uint32_t PopFloatingApplicationForDevelopment(OUT nn::am::service::IApplicationAccessor * _0); + uint32_t PopLaunchRequestedApplication(OUT nn::am::service::IApplicationAccessor * _0); + }; + class IApplicationFunctions { + public: + IApplicationFunctions(); + uint32_t BeginBlockingHomeButton(IN int64_t _0); + uint32_t BeginBlockingHomeButtonShortAndLongPressed(IN int64_t _0); + uint32_t CreateApplicationAndPushAndRequestToStart(IN nn::ncm::ApplicationId _0, IN nn::am::service::IStorage * _1); + uint32_t CreateApplicationAndPushAndRequestToStartForQuest(IN uint32_t _0, IN uint32_t _1, IN nn::ncm::ApplicationId _2, IN nn::am::service::IStorage * _3); + uint32_t EndBlockingHomeButton(); + uint32_t EndBlockingHomeButtonShortAndLongPressed(); + uint32_t EnsureSaveData(IN nn::account::Uid _0, OUT int64_t& _1); + uint32_t ExtendSaveData(IN uint8_t _0, IN nn::account::Uid _1, IN int64_t _2, IN int64_t _3, OUT int64_t& _4); + uint32_t GetDesiredLanguage(OUT nn::settings::LanguageCode& _0); + uint32_t GetDisplayVersion(OUT nn::oe::DisplayVersion& _0); + uint32_t GetLaunchStorageInfoForDebug(OUT nn::ncm::StorageId& _0, OUT nn::ncm::StorageId& _1); + uint32_t GetPseudoDeviceId(OUT nn::util::Uuid& _0); + uint32_t GetSaveDataSize(IN uint8_t _0, IN nn::account::Uid _1, OUT int64_t& _2, OUT int64_t& _3); + uint32_t InitializeGamePlayRecording(IN uint64_t _0, IN KObject * _1); + uint32_t IsGamePlayRecordingSupported(OUT bool& _0); + uint32_t NotifyRunning(OUT bool& _0); + uint32_t PopLaunchParameter(IN uint32_t _0, OUT nn::am::service::IStorage * _1); + uint32_t RequestToReboot(); + uint32_t RequestToShutdown(); + uint32_t SetGamePlayRecordingState(IN int32_t _0); + uint32_t SetMediaPlaybackStateForApplication(IN bool _0); + uint32_t SetTerminateResult(IN uint32_t _0); + }; + class IApplicationProxy { + public: + IApplicationProxy(); + uint32_t GetApplicationFunctions(OUT nn::am::service::IApplicationFunctions * _0); + uint32_t GetAudioController(OUT nn::am::service::IAudioController * _0); + uint32_t GetCommonStateGetter(OUT nn::am::service::ICommonStateGetter * _0); + uint32_t GetDebugFunctions(OUT nn::am::service::IDebugFunctions * _0); + uint32_t GetDisplayController(OUT nn::am::service::IDisplayController * _0); + uint32_t GetLibraryAppletCreator(OUT nn::am::service::ILibraryAppletCreator * _0); + uint32_t GetProcessWindingController(OUT nn::am::service::IProcessWindingController * _0); + uint32_t GetSelfController(OUT nn::am::service::ISelfController * _0); + uint32_t GetWindowController(OUT nn::am::service::IWindowController * _0); + }; + class IApplicationProxyService { + public: + IApplicationProxyService(); + uint32_t OpenApplicationProxy(IN uint64_t _0, IN gpid _1, IN KObject * _2, OUT nn::am::service::IApplicationProxy * _3); + }; + class IAudioController { + public: + IAudioController(); + uint32_t ChangeMainAppletMasterVolume(IN float32_t _0, IN int64_t _1); + uint32_t GetLibraryAppletExpectedMasterVolume(OUT float32_t& _0); + uint32_t GetMainAppletExpectedMasterVolume(OUT float32_t& _0); + uint32_t SetExpectedMasterVolume(IN float32_t _0, IN float32_t _1); + uint32_t SetTransparentVolumeRate(IN float32_t _0); + }; + class ICommonStateGetter { + public: + ICommonStateGetter(); + uint32_t AllowToEnterSleep(); + uint32_t DisallowToEnterSleep(); + uint32_t GetAcquiredSleepLockEvent(OUT KObject * _0); + uint32_t GetBootMode(OUT uint8_t& _0); + uint32_t GetCradleFwVersion(OUT uint32_t& _0, OUT uint32_t& _1, OUT uint32_t& _2, OUT uint32_t& _3); + uint32_t GetCradleStatus(OUT uint8_t& _0); + uint32_t GetCurrentFocusState(OUT uint8_t& _0); + uint32_t GetDefaultDisplayResolution(OUT int32_t& _0, OUT int32_t& _1); + uint32_t GetDefaultDisplayResolutionChangeEvent(OUT KObject * _0); + uint32_t GetEventHandle(OUT KObject * _0); + uint32_t GetHomeButtonReaderLockAccessor(OUT nn::am::service::ILockAccessor * _0); + uint32_t GetOperationMode(OUT uint8_t& _0); + uint32_t GetPerformanceMode(OUT uint32_t& _0); + uint32_t GetReaderLockAccessorEx(IN int32_t _0, OUT nn::am::service::ILockAccessor * _1); + uint32_t GetThisAppletKind(OUT nn::am::service::AppletKind& _0); + uint32_t IsInControllerFirmwareUpdateSection(OUT bool& _0); + uint32_t IsVrModeEnabled(OUT bool& _0); + uint32_t PushToGeneralChannel(IN nn::am::service::IStorage * _0); + uint32_t ReceiveMessage(OUT nn::am::AppletMessage& _0); + uint32_t ReleaseSleepLock(); + uint32_t ReleaseSleepLockTransiently(); + uint32_t RequestToAcquireSleepLock(); + uint32_t SetVrModeEnabled(IN bool _0); + }; + class IDebugFunctions { + public: + IDebugFunctions(); + uint32_t EmulateButtonEvent(IN nn::am::service::EmulatedButtonEvent _0); + uint32_t InvalidateTransitionLayer(); + uint32_t NotifyMessageToHomeMenuForDebug(IN nn::am::AppletMessage _0); + uint32_t OpenMainApplication(OUT nn::am::service::IApplicationAccessor * _0); + }; + class IDisplayController { + public: + IDisplayController(); + uint32_t AcquireCallerAppletCaptureBuffer(OUT KObject * _0); + uint32_t AcquireCallerAppletCaptureBufferEx(OUT bool& _0, OUT KObject * _1); + uint32_t AcquireLastApplicationCaptureBuffer(OUT KObject * _0); + uint32_t AcquireLastApplicationCaptureBufferEx(OUT bool& _0, OUT KObject * _1); + uint32_t AcquireLastForegroundCaptureBuffer(OUT KObject * _0); + uint32_t AcquireLastForegroundCaptureBufferEx(OUT bool& _0, OUT KObject * _1); + uint32_t ClearAppletTransitionBuffer(IN uint32_t _0); + uint32_t ClearCaptureBuffer(IN bool _0, IN int32_t _1, IN uint32_t _2); + uint32_t GetCallerAppletCaptureImage(OUT uint8_t * _0, guint _0_size); + uint32_t GetCallerAppletCaptureImageEx(OUT bool& _0, OUT uint8_t * _1, guint _1_size); + uint32_t GetLastApplicationCaptureImage(OUT uint8_t * _0, guint _0_size); + uint32_t GetLastApplicationCaptureImageEx(OUT bool& _0, OUT uint8_t * _1, guint _1_size); + uint32_t GetLastForegroundCaptureImage(OUT uint8_t * _0, guint _0_size); + uint32_t GetLastForegroundCaptureImageEx(OUT bool& _0, OUT uint8_t * _1, guint _1_size); + uint32_t ReleaseCallerAppletCaptureBuffer(); + uint32_t ReleaseLastApplicationCaptureBuffer(); + uint32_t ReleaseLastForegroundCaptureBuffer(); + uint32_t TakeScreenShotOfOwnLayer(IN bool _0, IN int32_t _1); + uint32_t UpdateCallerAppletCaptureImage(); + uint32_t UpdateLastForegroundCaptureImage(); + }; + class IGlobalStateController { + public: + IGlobalStateController(); + uint32_t EnterSleep(); + uint32_t LoadAndApplyIdlePolicySettings(); + uint32_t NotifyCecSettingsChanged(); + uint32_t RequestToEnterSleep(); + uint32_t SetDefaultHomeButtonLongPressTime(IN int64_t _0); + uint32_t ShouldSleepOnBoot(OUT bool& _0); + uint32_t StartRebootSequence(); + uint32_t StartShutdownSequence(); + uint32_t StartSleepSequence(IN bool _0); + uint32_t UpdateDefaultDisplayResolution(); + }; + class IHomeMenuFunctions { + public: + IHomeMenuFunctions(); + uint32_t GetHomeButtonWriterLockAccessor(OUT nn::am::service::ILockAccessor * _0); + uint32_t GetPopFromGeneralChannelEvent(OUT KObject * _0); + uint32_t GetWriterLockAccessorEx(IN int32_t _0, OUT nn::am::service::ILockAccessor * _1); + uint32_t LockForeground(); + uint32_t PopFromGeneralChannel(OUT nn::am::service::IStorage * _0); + uint32_t RequestToGetForeground(); + uint32_t UnlockForeground(); + }; + class ILibraryAppletAccessor { + public: + ILibraryAppletAccessor(); + uint32_t GetAppletStateChangedEvent(OUT KObject * _0); + uint32_t GetIndirectLayerConsumerHandle(IN nn::applet::AppletResourceUserId _0, IN gpid _1, OUT uint64_t& _2); + uint32_t GetLibraryAppletInfo(OUT nn::am::service::LibraryAppletInfo& _0); + uint32_t GetPopInteractiveOutDataEvent(OUT KObject * _0); + uint32_t GetPopOutDataEvent(OUT KObject * _0); + uint32_t GetResult(); + uint32_t IsCompleted(OUT bool& _0); + uint32_t NeedsToExitProcess(OUT bool& _0); + uint32_t PopInteractiveOutData(OUT nn::am::service::IStorage * _0); + uint32_t PopOutData(OUT nn::am::service::IStorage * _0); + uint32_t PushExtraStorage(IN nn::am::service::IStorage * _0); + uint32_t PushInData(IN nn::am::service::IStorage * _0); + uint32_t PushInteractiveInData(IN nn::am::service::IStorage * _0); + uint32_t RequestExit(); + uint32_t RequestForAppletToGetForeground(); + uint32_t SetOutOfFocusApplicationSuspendingEnabled(IN bool _0); + uint32_t Start(); + uint32_t Terminate(); + }; + class ILibraryAppletCreator { + public: + ILibraryAppletCreator(); + uint32_t AreAnyLibraryAppletsLeft(OUT bool& _0); + uint32_t CreateHandleStorage(IN int64_t _0, IN KObject * _1, OUT nn::am::service::IStorage * _2); + uint32_t CreateLibraryApplet(IN uint32_t _0, IN uint32_t _1, OUT nn::am::service::ILibraryAppletAccessor * _2); + uint32_t CreateStorage(IN int64_t _0, OUT nn::am::service::IStorage * _1); + uint32_t CreateTransferMemoryStorage(IN bool _0, IN int64_t _1, IN KObject * _2, OUT nn::am::service::IStorage * _3); + uint32_t TerminateAllLibraryApplets(); + }; + class ILibraryAppletProxy { + public: + ILibraryAppletProxy(); + uint32_t GetAudioController(OUT nn::am::service::IAudioController * _0); + uint32_t GetCommonStateGetter(OUT nn::am::service::ICommonStateGetter * _0); + uint32_t GetDebugFunctions(OUT nn::am::service::IDebugFunctions * _0); + uint32_t GetDisplayController(OUT nn::am::service::IDisplayController * _0); + uint32_t GetLibraryAppletCreator(OUT nn::am::service::ILibraryAppletCreator * _0); + uint32_t GetProcessWindingController(OUT nn::am::service::IProcessWindingController * _0); + uint32_t GetSelfController(OUT nn::am::service::ISelfController * _0); + uint32_t GetWindowController(OUT nn::am::service::IWindowController * _0); + uint32_t OpenLibraryAppletSelfAccessor(OUT nn::am::service::ILibraryAppletSelfAccessor * _0); + }; + class ILibraryAppletSelfAccessor { + public: + ILibraryAppletSelfAccessor(); + uint32_t CanUseApplicationCore(OUT bool& _0); + uint32_t ExitProcessAndReturn(); + uint32_t GetCallerAppletIdentityInfo(OUT nn::am::service::AppletIdentityInfo& _0); + uint32_t GetCallerAppletIdentityInfoStack(OUT int32_t& _0, OUT nn::am::service::AppletIdentityInfo * _1, guint _1_size); + uint32_t GetIndirectLayerProducerHandle(OUT uint64_t& _0); + uint32_t GetLibraryAppletInfo(OUT nn::am::service::LibraryAppletInfo& _0); + uint32_t GetMainAppletApplicationControlProperty(OUT nn::ns::ApplicationControlProperty * _0, guint _0_size); + uint32_t GetMainAppletIdentityInfo(OUT nn::am::service::AppletIdentityInfo& _0); + uint32_t GetMainAppletStorageId(OUT nn::ncm::StorageId& _0); + uint32_t GetPopExtraStorageEvent(OUT KObject * _0); + uint32_t GetPopInDataEvent(OUT KObject * _0); + uint32_t GetPopInteractiveInDataEvent(OUT KObject * _0); + uint32_t PopExtraStorage(OUT nn::am::service::IStorage * _0); + uint32_t PopInData(OUT nn::am::service::IStorage * _0); + uint32_t PopInteractiveInData(OUT nn::am::service::IStorage * _0); + uint32_t PushInteractiveOutData(IN nn::am::service::IStorage * _0); + uint32_t PushOutData(IN nn::am::service::IStorage * _0); + uint32_t ReportVisibleError(IN nn::err::ErrorCode _0); + uint32_t UnpopExtraStorage(IN nn::am::service::IStorage * _0); + uint32_t UnpopInData(IN nn::am::service::IStorage * _0); + }; + class ILockAccessor { + public: + ILockAccessor(); + uint32_t GetEvent(OUT KObject * _0); + uint32_t TryLock(IN bool _0, OUT bool& _1, OUT KObject * _2); + uint32_t Unlock(); + }; + class IOverlayAppletProxy { + public: + IOverlayAppletProxy(); + uint32_t GetAudioController(OUT nn::am::service::IAudioController * _0); + uint32_t GetCommonStateGetter(OUT nn::am::service::ICommonStateGetter * _0); + uint32_t GetDebugFunctions(OUT nn::am::service::IDebugFunctions * _0); + uint32_t GetDisplayController(OUT nn::am::service::IDisplayController * _0); + uint32_t GetLibraryAppletCreator(OUT nn::am::service::ILibraryAppletCreator * _0); + uint32_t GetOverlayFunctions(OUT nn::am::service::IOverlayFunctions * _0); + uint32_t GetProcessWindingController(OUT nn::am::service::IProcessWindingController * _0); + uint32_t GetSelfController(OUT nn::am::service::ISelfController * _0); + uint32_t GetWindowController(OUT nn::am::service::IWindowController * _0); + }; + class IOverlayFunctions { + public: + IOverlayFunctions(); + uint32_t BeginToWatchShortHomeButtonMessage(); + uint32_t EndToWatchShortHomeButtonMessage(); + uint32_t GetApplicationIdForLogo(OUT nn::ncm::ApplicationId& _0); + uint32_t SetAutoSleepTimeAndDimmingTimeEnabled(IN bool _0); + uint32_t SetGpuTimeSliceBoost(IN uint64_t _0); + uint32_t SetScreenShotPermissionGlobally(IN bool _0); + uint32_t TerminateApplicationAndSetReason(IN uint32_t _0); + }; + class IProcessWindingController { + public: + IProcessWindingController(); + uint32_t CancelWindingReservation(); + uint32_t GetLaunchReason(OUT nn::am::service::AppletProcessLaunchReason& _0); + uint32_t OpenCallingLibraryApplet(OUT nn::am::service::ILibraryAppletAccessor * _0); + uint32_t PopContext(OUT nn::am::service::IStorage * _0); + uint32_t PushContext(IN nn::am::service::IStorage * _0); + uint32_t ReserveToStartAndWaitAndUnwindThis(IN nn::am::service::ILibraryAppletAccessor * _0); + uint32_t WindAndDoReserved(); + }; + class ISelfController { + public: + ISelfController(); + uint32_t ApproveToDisplay(); + uint32_t CreateManagedDisplayLayer(OUT uint64_t& _0); + uint32_t EnterFatalSection(); + uint32_t Exit(); + uint32_t GetCurrentIlluminance(OUT float32_t& _0); + uint32_t GetIdleTimeDetectionExtension(OUT uint32_t& _0); + uint32_t GetLibraryAppletLaunchableEvent(OUT KObject * _0); + uint32_t IsIlluminanceAvailable(OUT bool& _0); + uint32_t LeaveFatalSection(); + uint32_t LockExit(); + uint32_t OverrideAutoSleepTimeAndDimmingTime(IN int32_t _0, IN int32_t _1, IN int32_t _2, IN int32_t _3); + uint32_t ReportUserIsActive(); + uint32_t SetControllerFirmwareUpdateSection(IN bool _0); + uint32_t SetFocusHandlingMode(IN bool _0, IN bool _1, IN bool _2); + uint32_t SetHandlesRequestToDisplay(IN bool _0); + uint32_t SetIdleTimeDetectionExtension(IN uint32_t _0); + uint32_t SetInputDetectionSourceSet(IN uint32_t _0); + uint32_t SetMediaPlaybackState(IN bool _0); + uint32_t SetOperationModeChangedNotification(IN bool _0); + uint32_t SetOutOfFocusSuspendingEnabled(IN bool _0); + uint32_t SetPerformanceModeChangedNotification(IN bool _0); + uint32_t SetRequiresCaptureButtonShortPressedMessage(IN bool _0); + uint32_t SetRestartMessageEnabled(IN bool _0); + uint32_t SetScreenShotAppletIdentityInfo(IN nn::am::service::AppletIdentityInfo _0); + uint32_t SetScreenShotImageOrientation(IN int32_t _0); + uint32_t SetScreenShotPermission(IN int32_t _0); + uint32_t UnlockExit(); + }; + class IStorage { + public: + IStorage(); + uint32_t Open(OUT nn::am::service::IStorageAccessor * _0); + uint32_t OpenTransferStorage(OUT nn::am::service::ITransferStorageAccessor * _0); + }; + class IStorageAccessor { + public: + IStorageAccessor(); + uint32_t GetSize(OUT int64_t& _0); + uint32_t Read(IN int64_t _0, OUT uint8_t * _1, guint _1_size); + uint32_t Write(IN int64_t _0, IN uint8_t * _1, guint _1_size); + }; + class ISystemAppletProxy { + public: + ISystemAppletProxy(); + uint32_t GetApplicationCreator(OUT nn::am::service::IApplicationCreator * _0); + uint32_t GetAudioController(OUT nn::am::service::IAudioController * _0); + uint32_t GetCommonStateGetter(OUT nn::am::service::ICommonStateGetter * _0); + uint32_t GetDebugFunctions(OUT nn::am::service::IDebugFunctions * _0); + uint32_t GetDisplayController(OUT nn::am::service::IDisplayController * _0); + uint32_t GetGlobalStateController(OUT nn::am::service::IGlobalStateController * _0); + uint32_t GetHomeMenuFunctions(OUT nn::am::service::IHomeMenuFunctions * _0); + uint32_t GetLibraryAppletCreator(OUT nn::am::service::ILibraryAppletCreator * _0); + uint32_t GetProcessWindingController(OUT nn::am::service::IProcessWindingController * _0); + uint32_t GetSelfController(OUT nn::am::service::ISelfController * _0); + uint32_t GetWindowController(OUT nn::am::service::IWindowController * _0); + }; + class ITransferStorageAccessor { + public: + ITransferStorageAccessor(); + uint32_t GetHandle(OUT uint64_t& _0, OUT KObject * _1); + uint32_t GetSize(OUT int64_t& _0); + }; + class IWindow { + public: + IWindow(); + uint32_t Unknown12345(); + }; + class IWindowController { + public: + IWindowController(); + uint32_t AcquireForegroundRights(); + uint32_t CreateWindow(IN nn::am::service::WindowCreationOption _0, OUT nn::am::service::IWindow * _1); + uint32_t GetAppletResourceUserId(OUT nn::applet::AppletResourceUserId& _0); + uint32_t RejectToChangeIntoBackground(); + uint32_t ReleaseForegroundRights(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::am::service::IAllSystemAppletProxiesService::CreateSelfLibraryAppletCreatorForDevelop(IN uint64_t _0, IN gpid _1, OUT nn::am::service::ILibraryAppletCreator * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _2 OMG = new nn::am::service::ILibraryAppletCreator(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::IAllSystemAppletProxiesService::OpenLibraryAppletProxy(IN uint64_t _0, IN gpid _1, IN KObject * _2, IN nn::am::AppletAttribute * _3, guint _3_size, OUT nn::am::service::ILibraryAppletProxy * _4) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x15, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + _4 OMG = new nn::am::service::ILibraryAppletProxy(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::IAllSystemAppletProxiesService::OpenLibraryAppletProxyOld(IN uint64_t _0, IN gpid _1, IN KObject * _2, OUT nn::am::service::ILibraryAppletProxy * _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _3 OMG = new nn::am::service::ILibraryAppletProxy(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::IAllSystemAppletProxiesService::OpenOverlayAppletProxy(IN uint64_t _0, IN gpid _1, IN KObject * _2, OUT nn::am::service::IOverlayAppletProxy * _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _3 OMG = new nn::am::service::IOverlayAppletProxy(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::IAllSystemAppletProxiesService::OpenSystemAppletProxy(IN uint64_t _0, IN gpid _1, IN KObject * _2, OUT nn::am::service::ISystemAppletProxy * _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _3 OMG = new nn::am::service::ISystemAppletProxy(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::IAllSystemAppletProxiesService::OpenSystemApplicationProxy(IN uint64_t _0, IN gpid _1, IN KObject * _2, OUT nn::am::service::IApplicationProxy * _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _3 OMG = new nn::am::service::IApplicationProxy(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::IAppletAccessor::GetAppletStateChangedEvent(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::am::service::IAppletAccessor::GetResult() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IAppletAccessor::IsCompleted(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IAppletAccessor::RequestExit() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IAppletAccessor::Start() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IAppletAccessor::Terminate() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IApplicationAccessor::AreAnyLibraryAppletsLeft(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IApplicationAccessor::GetAppletStateChangedEvent(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::am::service::IApplicationAccessor::GetApplicationControlProperty(OUT uint8_t * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::am::service::IApplicationAccessor::GetApplicationId(OUT nn::ncm::ApplicationId& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IApplicationAccessor::GetApplicationLaunchProperty(OUT uint8_t * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::am::service::IApplicationAccessor::GetCurrentLibraryApplet(OUT nn::am::service::IAppletAccessor * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::IAppletAccessor(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::IApplicationAccessor::GetResult() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IApplicationAccessor::IsCompleted(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IApplicationAccessor::PushLaunchParameter(IN uint32_t _0, IN nn::am::service::IStorage * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IApplicationAccessor::RequestExit() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IApplicationAccessor::RequestForApplicationToGetForeground() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IApplicationAccessor::Start() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IApplicationAccessor::Terminate() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IApplicationAccessor::TerminateAllLibraryApplets() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IApplicationCreator::CreateApplication(IN nn::ncm::ApplicationId _0, OUT nn::am::service::IApplicationAccessor * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new nn::am::service::IApplicationAccessor(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::IApplicationCreator::CreateSystemApplication(IN nn::ncm::SystemApplicationId _0, OUT nn::am::service::IApplicationAccessor * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new nn::am::service::IApplicationAccessor(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::IApplicationCreator::PopFloatingApplicationForDevelopment(OUT nn::am::service::IApplicationAccessor * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::IApplicationAccessor(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::IApplicationCreator::PopLaunchRequestedApplication(OUT nn::am::service::IApplicationAccessor * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::IApplicationAccessor(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::IApplicationFunctions::BeginBlockingHomeButton(IN int64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IApplicationFunctions::BeginBlockingHomeButtonShortAndLongPressed(IN int64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IApplicationFunctions::CreateApplicationAndPushAndRequestToStart(IN nn::ncm::ApplicationId _0, IN nn::am::service::IStorage * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IApplicationFunctions::CreateApplicationAndPushAndRequestToStartForQuest(IN uint32_t _0, IN uint32_t _1, IN nn::ncm::ApplicationId _2, IN nn::am::service::IStorage * _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IApplicationFunctions::EndBlockingHomeButton() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IApplicationFunctions::EndBlockingHomeButtonShortAndLongPressed() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IApplicationFunctions::EnsureSaveData(IN nn::account::Uid _0, OUT int64_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IApplicationFunctions::ExtendSaveData(IN uint8_t _0, IN nn::account::Uid _1, IN int64_t _2, IN int64_t _3, OUT int64_t& _4) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IApplicationFunctions::GetDesiredLanguage(OUT nn::settings::LanguageCode& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IApplicationFunctions::GetDisplayVersion(OUT nn::oe::DisplayVersion& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IApplicationFunctions::GetLaunchStorageInfoForDebug(OUT nn::ncm::StorageId& _0, OUT nn::ncm::StorageId& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IApplicationFunctions::GetPseudoDeviceId(OUT nn::util::Uuid& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IApplicationFunctions::GetSaveDataSize(IN uint8_t _0, IN nn::account::Uid _1, OUT int64_t& _2, OUT int64_t& _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IApplicationFunctions::InitializeGamePlayRecording(IN uint64_t _0, IN KObject * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IApplicationFunctions::IsGamePlayRecordingSupported(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IApplicationFunctions::NotifyRunning(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IApplicationFunctions::PopLaunchParameter(IN uint32_t _0, OUT nn::am::service::IStorage * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new nn::am::service::IStorage(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::IApplicationFunctions::RequestToReboot() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IApplicationFunctions::RequestToShutdown() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IApplicationFunctions::SetGamePlayRecordingState(IN int32_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IApplicationFunctions::SetMediaPlaybackStateForApplication(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IApplicationFunctions::SetTerminateResult(IN uint32_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IApplicationProxy::GetApplicationFunctions(OUT nn::am::service::IApplicationFunctions * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::IApplicationFunctions(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::IApplicationProxy::GetAudioController(OUT nn::am::service::IAudioController * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::IAudioController(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::IApplicationProxy::GetCommonStateGetter(OUT nn::am::service::ICommonStateGetter * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::ICommonStateGetter(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::IApplicationProxy::GetDebugFunctions(OUT nn::am::service::IDebugFunctions * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::IDebugFunctions(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::IApplicationProxy::GetDisplayController(OUT nn::am::service::IDisplayController * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::IDisplayController(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::IApplicationProxy::GetLibraryAppletCreator(OUT nn::am::service::ILibraryAppletCreator * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::ILibraryAppletCreator(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::IApplicationProxy::GetProcessWindingController(OUT nn::am::service::IProcessWindingController * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::IProcessWindingController(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::IApplicationProxy::GetSelfController(OUT nn::am::service::ISelfController * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::ISelfController(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::IApplicationProxy::GetWindowController(OUT nn::am::service::IWindowController * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::IWindowController(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::IApplicationProxyService::OpenApplicationProxy(IN uint64_t _0, IN gpid _1, IN KObject * _2, OUT nn::am::service::IApplicationProxy * _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _3 OMG = new nn::am::service::IApplicationProxy(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::IAudioController::ChangeMainAppletMasterVolume(IN float32_t _0, IN int64_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IAudioController::GetLibraryAppletExpectedMasterVolume(OUT float32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IAudioController::GetMainAppletExpectedMasterVolume(OUT float32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IAudioController::SetExpectedMasterVolume(IN float32_t _0, IN float32_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IAudioController::SetTransparentVolumeRate(IN float32_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ICommonStateGetter::AllowToEnterSleep() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ICommonStateGetter::DisallowToEnterSleep() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ICommonStateGetter::GetAcquiredSleepLockEvent(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::am::service::ICommonStateGetter::GetBootMode(OUT uint8_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ICommonStateGetter::GetCradleFwVersion(OUT uint32_t& _0, OUT uint32_t& _1, OUT uint32_t& _2, OUT uint32_t& _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ICommonStateGetter::GetCradleStatus(OUT uint8_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ICommonStateGetter::GetCurrentFocusState(OUT uint8_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ICommonStateGetter::GetDefaultDisplayResolution(OUT int32_t& _0, OUT int32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ICommonStateGetter::GetDefaultDisplayResolutionChangeEvent(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::am::service::ICommonStateGetter::GetEventHandle(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::am::service::ICommonStateGetter::GetHomeButtonReaderLockAccessor(OUT nn::am::service::ILockAccessor * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::ILockAccessor(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::ICommonStateGetter::GetOperationMode(OUT uint8_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ICommonStateGetter::GetPerformanceMode(OUT uint32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ICommonStateGetter::GetReaderLockAccessorEx(IN int32_t _0, OUT nn::am::service::ILockAccessor * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new nn::am::service::ILockAccessor(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::ICommonStateGetter::GetThisAppletKind(OUT nn::am::service::AppletKind& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ICommonStateGetter::IsInControllerFirmwareUpdateSection(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ICommonStateGetter::IsVrModeEnabled(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ICommonStateGetter::PushToGeneralChannel(IN nn::am::service::IStorage * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ICommonStateGetter::ReceiveMessage(OUT nn::am::AppletMessage& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ICommonStateGetter::ReleaseSleepLock() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ICommonStateGetter::ReleaseSleepLockTransiently() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ICommonStateGetter::RequestToAcquireSleepLock() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ICommonStateGetter::SetVrModeEnabled(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IDebugFunctions::EmulateButtonEvent(IN nn::am::service::EmulatedButtonEvent _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IDebugFunctions::InvalidateTransitionLayer() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IDebugFunctions::NotifyMessageToHomeMenuForDebug(IN nn::am::AppletMessage _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IDebugFunctions::OpenMainApplication(OUT nn::am::service::IApplicationAccessor * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::IApplicationAccessor(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::IDisplayController::AcquireCallerAppletCaptureBuffer(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::am::service::IDisplayController::AcquireCallerAppletCaptureBufferEx(OUT bool& _0, OUT KObject * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::am::service::IDisplayController::AcquireLastApplicationCaptureBuffer(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::am::service::IDisplayController::AcquireLastApplicationCaptureBufferEx(OUT bool& _0, OUT KObject * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::am::service::IDisplayController::AcquireLastForegroundCaptureBuffer(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::am::service::IDisplayController::AcquireLastForegroundCaptureBufferEx(OUT bool& _0, OUT KObject * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::am::service::IDisplayController::ClearAppletTransitionBuffer(IN uint32_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IDisplayController::ClearCaptureBuffer(IN bool _0, IN int32_t _1, IN uint32_t _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IDisplayController::GetCallerAppletCaptureImage(OUT uint8_t * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::am::service::IDisplayController::GetCallerAppletCaptureImageEx(OUT bool& _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::am::service::IDisplayController::GetLastApplicationCaptureImage(OUT uint8_t * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::am::service::IDisplayController::GetLastApplicationCaptureImageEx(OUT bool& _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::am::service::IDisplayController::GetLastForegroundCaptureImage(OUT uint8_t * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::am::service::IDisplayController::GetLastForegroundCaptureImageEx(OUT bool& _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::am::service::IDisplayController::ReleaseCallerAppletCaptureBuffer() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IDisplayController::ReleaseLastApplicationCaptureBuffer() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IDisplayController::ReleaseLastForegroundCaptureBuffer() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IDisplayController::TakeScreenShotOfOwnLayer(IN bool _0, IN int32_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IDisplayController::UpdateCallerAppletCaptureImage() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IDisplayController::UpdateLastForegroundCaptureImage() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IGlobalStateController::EnterSleep() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IGlobalStateController::LoadAndApplyIdlePolicySettings() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IGlobalStateController::NotifyCecSettingsChanged() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IGlobalStateController::RequestToEnterSleep() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IGlobalStateController::SetDefaultHomeButtonLongPressTime(IN int64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IGlobalStateController::ShouldSleepOnBoot(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IGlobalStateController::StartRebootSequence() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IGlobalStateController::StartShutdownSequence() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IGlobalStateController::StartSleepSequence(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IGlobalStateController::UpdateDefaultDisplayResolution() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IHomeMenuFunctions::GetHomeButtonWriterLockAccessor(OUT nn::am::service::ILockAccessor * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::ILockAccessor(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::IHomeMenuFunctions::GetPopFromGeneralChannelEvent(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::am::service::IHomeMenuFunctions::GetWriterLockAccessorEx(IN int32_t _0, OUT nn::am::service::ILockAccessor * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new nn::am::service::ILockAccessor(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::IHomeMenuFunctions::LockForeground() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IHomeMenuFunctions::PopFromGeneralChannel(OUT nn::am::service::IStorage * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::IStorage(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::IHomeMenuFunctions::RequestToGetForeground() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IHomeMenuFunctions::UnlockForeground() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ILibraryAppletAccessor::GetAppletStateChangedEvent(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::am::service::ILibraryAppletAccessor::GetIndirectLayerConsumerHandle(IN nn::applet::AppletResourceUserId _0, IN gpid _1, OUT uint64_t& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ILibraryAppletAccessor::GetLibraryAppletInfo(OUT nn::am::service::LibraryAppletInfo& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ILibraryAppletAccessor::GetPopInteractiveOutDataEvent(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::am::service::ILibraryAppletAccessor::GetPopOutDataEvent(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::am::service::ILibraryAppletAccessor::GetResult() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ILibraryAppletAccessor::IsCompleted(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ILibraryAppletAccessor::NeedsToExitProcess(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ILibraryAppletAccessor::PopInteractiveOutData(OUT nn::am::service::IStorage * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::IStorage(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::ILibraryAppletAccessor::PopOutData(OUT nn::am::service::IStorage * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::IStorage(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::ILibraryAppletAccessor::PushExtraStorage(IN nn::am::service::IStorage * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ILibraryAppletAccessor::PushInData(IN nn::am::service::IStorage * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ILibraryAppletAccessor::PushInteractiveInData(IN nn::am::service::IStorage * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ILibraryAppletAccessor::RequestExit() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ILibraryAppletAccessor::RequestForAppletToGetForeground() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ILibraryAppletAccessor::SetOutOfFocusApplicationSuspendingEnabled(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ILibraryAppletAccessor::Start() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ILibraryAppletAccessor::Terminate() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ILibraryAppletCreator::AreAnyLibraryAppletsLeft(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ILibraryAppletCreator::CreateHandleStorage(IN int64_t _0, IN KObject * _1, OUT nn::am::service::IStorage * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _2 OMG = new nn::am::service::IStorage(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::ILibraryAppletCreator::CreateLibraryApplet(IN uint32_t _0, IN uint32_t _1, OUT nn::am::service::ILibraryAppletAccessor * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _2 OMG = new nn::am::service::ILibraryAppletAccessor(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::ILibraryAppletCreator::CreateStorage(IN int64_t _0, OUT nn::am::service::IStorage * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new nn::am::service::IStorage(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::ILibraryAppletCreator::CreateTransferMemoryStorage(IN bool _0, IN int64_t _1, IN KObject * _2, OUT nn::am::service::IStorage * _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _3 OMG = new nn::am::service::IStorage(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::ILibraryAppletCreator::TerminateAllLibraryApplets() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ILibraryAppletProxy::GetAudioController(OUT nn::am::service::IAudioController * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::IAudioController(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::ILibraryAppletProxy::GetCommonStateGetter(OUT nn::am::service::ICommonStateGetter * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::ICommonStateGetter(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::ILibraryAppletProxy::GetDebugFunctions(OUT nn::am::service::IDebugFunctions * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::IDebugFunctions(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::ILibraryAppletProxy::GetDisplayController(OUT nn::am::service::IDisplayController * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::IDisplayController(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::ILibraryAppletProxy::GetLibraryAppletCreator(OUT nn::am::service::ILibraryAppletCreator * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::ILibraryAppletCreator(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::ILibraryAppletProxy::GetProcessWindingController(OUT nn::am::service::IProcessWindingController * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::IProcessWindingController(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::ILibraryAppletProxy::GetSelfController(OUT nn::am::service::ISelfController * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::ISelfController(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::ILibraryAppletProxy::GetWindowController(OUT nn::am::service::IWindowController * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::IWindowController(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::ILibraryAppletProxy::OpenLibraryAppletSelfAccessor(OUT nn::am::service::ILibraryAppletSelfAccessor * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::ILibraryAppletSelfAccessor(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::ILibraryAppletSelfAccessor::CanUseApplicationCore(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ILibraryAppletSelfAccessor::ExitProcessAndReturn() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ILibraryAppletSelfAccessor::GetCallerAppletIdentityInfo(OUT nn::am::service::AppletIdentityInfo& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ILibraryAppletSelfAccessor::GetCallerAppletIdentityInfoStack(OUT int32_t& _0, OUT nn::am::service::AppletIdentityInfo * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::am::service::ILibraryAppletSelfAccessor::GetIndirectLayerProducerHandle(OUT uint64_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ILibraryAppletSelfAccessor::GetLibraryAppletInfo(OUT nn::am::service::LibraryAppletInfo& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ILibraryAppletSelfAccessor::GetMainAppletApplicationControlProperty(OUT nn::ns::ApplicationControlProperty * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x16, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::am::service::ILibraryAppletSelfAccessor::GetMainAppletIdentityInfo(OUT nn::am::service::AppletIdentityInfo& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ILibraryAppletSelfAccessor::GetMainAppletStorageId(OUT nn::ncm::StorageId& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ILibraryAppletSelfAccessor::GetPopExtraStorageEvent(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::am::service::ILibraryAppletSelfAccessor::GetPopInDataEvent(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::am::service::ILibraryAppletSelfAccessor::GetPopInteractiveInDataEvent(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::am::service::ILibraryAppletSelfAccessor::PopExtraStorage(OUT nn::am::service::IStorage * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::IStorage(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::ILibraryAppletSelfAccessor::PopInData(OUT nn::am::service::IStorage * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::IStorage(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::ILibraryAppletSelfAccessor::PopInteractiveInData(OUT nn::am::service::IStorage * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::IStorage(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::ILibraryAppletSelfAccessor::PushInteractiveOutData(IN nn::am::service::IStorage * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ILibraryAppletSelfAccessor::PushOutData(IN nn::am::service::IStorage * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ILibraryAppletSelfAccessor::ReportVisibleError(IN nn::err::ErrorCode _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ILibraryAppletSelfAccessor::UnpopExtraStorage(IN nn::am::service::IStorage * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ILibraryAppletSelfAccessor::UnpopInData(IN nn::am::service::IStorage * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ILockAccessor::GetEvent(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::am::service::ILockAccessor::TryLock(IN bool _0, OUT bool& _1, OUT KObject * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::am::service::ILockAccessor::Unlock() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IOverlayAppletProxy::GetAudioController(OUT nn::am::service::IAudioController * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::IAudioController(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::IOverlayAppletProxy::GetCommonStateGetter(OUT nn::am::service::ICommonStateGetter * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::ICommonStateGetter(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::IOverlayAppletProxy::GetDebugFunctions(OUT nn::am::service::IDebugFunctions * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::IDebugFunctions(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::IOverlayAppletProxy::GetDisplayController(OUT nn::am::service::IDisplayController * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::IDisplayController(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::IOverlayAppletProxy::GetLibraryAppletCreator(OUT nn::am::service::ILibraryAppletCreator * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::ILibraryAppletCreator(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::IOverlayAppletProxy::GetOverlayFunctions(OUT nn::am::service::IOverlayFunctions * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::IOverlayFunctions(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::IOverlayAppletProxy::GetProcessWindingController(OUT nn::am::service::IProcessWindingController * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::IProcessWindingController(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::IOverlayAppletProxy::GetSelfController(OUT nn::am::service::ISelfController * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::ISelfController(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::IOverlayAppletProxy::GetWindowController(OUT nn::am::service::IWindowController * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::IWindowController(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::IOverlayFunctions::BeginToWatchShortHomeButtonMessage() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IOverlayFunctions::EndToWatchShortHomeButtonMessage() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IOverlayFunctions::GetApplicationIdForLogo(OUT nn::ncm::ApplicationId& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IOverlayFunctions::SetAutoSleepTimeAndDimmingTimeEnabled(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IOverlayFunctions::SetGpuTimeSliceBoost(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IOverlayFunctions::SetScreenShotPermissionGlobally(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IOverlayFunctions::TerminateApplicationAndSetReason(IN uint32_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IProcessWindingController::CancelWindingReservation() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IProcessWindingController::GetLaunchReason(OUT nn::am::service::AppletProcessLaunchReason& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IProcessWindingController::OpenCallingLibraryApplet(OUT nn::am::service::ILibraryAppletAccessor * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::ILibraryAppletAccessor(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::IProcessWindingController::PopContext(OUT nn::am::service::IStorage * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::IStorage(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::IProcessWindingController::PushContext(IN nn::am::service::IStorage * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IProcessWindingController::ReserveToStartAndWaitAndUnwindThis(IN nn::am::service::ILibraryAppletAccessor * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IProcessWindingController::WindAndDoReserved() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ISelfController::ApproveToDisplay() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ISelfController::CreateManagedDisplayLayer(OUT uint64_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ISelfController::EnterFatalSection() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ISelfController::Exit() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ISelfController::GetCurrentIlluminance(OUT float32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ISelfController::GetIdleTimeDetectionExtension(OUT uint32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ISelfController::GetLibraryAppletLaunchableEvent(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::am::service::ISelfController::IsIlluminanceAvailable(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ISelfController::LeaveFatalSection() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ISelfController::LockExit() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ISelfController::OverrideAutoSleepTimeAndDimmingTime(IN int32_t _0, IN int32_t _1, IN int32_t _2, IN int32_t _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ISelfController::ReportUserIsActive() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ISelfController::SetControllerFirmwareUpdateSection(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ISelfController::SetFocusHandlingMode(IN bool _0, IN bool _1, IN bool _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ISelfController::SetHandlesRequestToDisplay(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ISelfController::SetIdleTimeDetectionExtension(IN uint32_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ISelfController::SetInputDetectionSourceSet(IN uint32_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ISelfController::SetMediaPlaybackState(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ISelfController::SetOperationModeChangedNotification(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ISelfController::SetOutOfFocusSuspendingEnabled(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ISelfController::SetPerformanceModeChangedNotification(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ISelfController::SetRequiresCaptureButtonShortPressedMessage(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ISelfController::SetRestartMessageEnabled(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ISelfController::SetScreenShotAppletIdentityInfo(IN nn::am::service::AppletIdentityInfo _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ISelfController::SetScreenShotImageOrientation(IN int32_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ISelfController::SetScreenShotPermission(IN int32_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::ISelfController::UnlockExit() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IStorage::Open(OUT nn::am::service::IStorageAccessor * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::IStorageAccessor(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::IStorage::OpenTransferStorage(OUT nn::am::service::ITransferStorageAccessor * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::ITransferStorageAccessor(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::IStorageAccessor::GetSize(OUT int64_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IStorageAccessor::Read(IN int64_t _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x22, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::am::service::IStorageAccessor::Write(IN int64_t _0, IN uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x21, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::am::service::ISystemAppletProxy::GetApplicationCreator(OUT nn::am::service::IApplicationCreator * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::IApplicationCreator(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::ISystemAppletProxy::GetAudioController(OUT nn::am::service::IAudioController * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::IAudioController(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::ISystemAppletProxy::GetCommonStateGetter(OUT nn::am::service::ICommonStateGetter * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::ICommonStateGetter(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::ISystemAppletProxy::GetDebugFunctions(OUT nn::am::service::IDebugFunctions * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::IDebugFunctions(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::ISystemAppletProxy::GetDisplayController(OUT nn::am::service::IDisplayController * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::IDisplayController(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::ISystemAppletProxy::GetGlobalStateController(OUT nn::am::service::IGlobalStateController * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::IGlobalStateController(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::ISystemAppletProxy::GetHomeMenuFunctions(OUT nn::am::service::IHomeMenuFunctions * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::IHomeMenuFunctions(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::ISystemAppletProxy::GetLibraryAppletCreator(OUT nn::am::service::ILibraryAppletCreator * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::ILibraryAppletCreator(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::ISystemAppletProxy::GetProcessWindingController(OUT nn::am::service::IProcessWindingController * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::IProcessWindingController(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::ISystemAppletProxy::GetSelfController(OUT nn::am::service::ISelfController * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::ISelfController(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::ISystemAppletProxy::GetWindowController(OUT nn::am::service::IWindowController * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::am::service::IWindowController(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::ITransferStorageAccessor::GetHandle(OUT uint64_t& _0, OUT KObject * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::am::service::ITransferStorageAccessor::GetSize(OUT int64_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IWindow::Unknown12345() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IWindowController::AcquireForegroundRights() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IWindowController::CreateWindow(IN nn::am::service::WindowCreationOption _0, OUT nn::am::service::IWindow * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new nn::am::service::IWindow(resp.move_handles[0]); + return ret; +} +uint32_t nn::am::service::IWindowController::GetAppletResourceUserId(OUT nn::applet::AppletResourceUserId& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IWindowController::RejectToChangeIntoBackground() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::am::service::IWindowController::ReleaseForegroundRights() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::aocsrv::detail { + class IAddOnContentManager { + public: + IAddOnContentManager(); + uint32_t CountAddOnContent(IN uint64_t _0, IN gpid _1, OUT int32_t& _2); + uint32_t CountAddOnContentByApplicationId(IN nn::ncm::ApplicationId _0, OUT int32_t& _1); + uint32_t GetAddOnContentBaseId(IN uint64_t _0, IN gpid _1, OUT uint64_t& _2); + uint32_t GetAddOnContentBaseIdByApplicationId(IN nn::ncm::ApplicationId _0, OUT uint64_t& _1); + uint32_t ListAddOnContent(IN int32_t _0, IN int32_t _1, IN uint64_t _2, IN gpid _3, OUT int32_t& _4, OUT int32_t * _5, guint _5_size); + uint32_t ListAddOnContentByApplicationId(IN int32_t _0, IN int32_t _1, IN nn::ncm::ApplicationId _2, OUT int32_t& _3, OUT int32_t * _4, guint _4_size); + uint32_t PrepareAddOnContent(IN int32_t _0, IN uint64_t _1, IN gpid _2); + uint32_t PrepareAddOnContentByApplicationId(IN int32_t _0, IN nn::ncm::ApplicationId _1); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::aocsrv::detail::IAddOnContentManager::CountAddOnContent(IN uint64_t _0, IN gpid _1, OUT int32_t& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::aocsrv::detail::IAddOnContentManager::CountAddOnContentByApplicationId(IN nn::ncm::ApplicationId _0, OUT int32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::aocsrv::detail::IAddOnContentManager::GetAddOnContentBaseId(IN uint64_t _0, IN gpid _1, OUT uint64_t& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::aocsrv::detail::IAddOnContentManager::GetAddOnContentBaseIdByApplicationId(IN nn::ncm::ApplicationId _0, OUT uint64_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::aocsrv::detail::IAddOnContentManager::ListAddOnContent(IN int32_t _0, IN int32_t _1, IN uint64_t _2, IN gpid _3, OUT int32_t& _4, OUT int32_t * _5, guint _5_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::aocsrv::detail::IAddOnContentManager::ListAddOnContentByApplicationId(IN int32_t _0, IN int32_t _1, IN nn::ncm::ApplicationId _2, OUT int32_t& _3, OUT int32_t * _4, guint _4_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::aocsrv::detail::IAddOnContentManager::PrepareAddOnContent(IN int32_t _0, IN uint64_t _1, IN gpid _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::aocsrv::detail::IAddOnContentManager::PrepareAddOnContentByApplicationId(IN int32_t _0, IN nn::ncm::ApplicationId _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::apm { + class IManager { + public: + IManager(); + uint32_t GetPerformanceMode(OUT nn::apm::PerformanceMode& _0); + uint32_t OpenSession(OUT nn::apm::ISession * _0); + }; + class IManagerPrivileged { + public: + IManagerPrivileged(); + uint32_t OpenSession(OUT nn::apm::ISession * _0); + }; + class ISession { + public: + ISession(); + uint32_t GetPerformanceConfiguration(IN nn::apm::PerformanceMode _0, OUT nn::apm::PerformanceConfiguration& _1); + uint32_t SetPerformanceConfiguration(IN nn::apm::PerformanceMode _0, IN nn::apm::PerformanceConfiguration _1); + }; + class ISystemManager { + public: + ISystemManager(); + uint32_t ClearLastThrottlingState(); + uint32_t GetLastThrottlingState(OUT nn::apm::ThrottlingState& _0); + uint32_t GetPerformanceEvent(IN nn::apm::EventTarget _0, OUT KObject * _1); + uint32_t GetThrottlingState(OUT nn::apm::ThrottlingState& _0); + uint32_t RequestPerformanceMode(IN nn::apm::PerformanceMode _0); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::apm::IManager::GetPerformanceMode(OUT nn::apm::PerformanceMode& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::apm::IManager::OpenSession(OUT nn::apm::ISession * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::apm::ISession(resp.move_handles[0]); + return ret; +} +uint32_t nn::apm::IManagerPrivileged::OpenSession(OUT nn::apm::ISession * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::apm::ISession(resp.move_handles[0]); + return ret; +} +uint32_t nn::apm::ISession::GetPerformanceConfiguration(IN nn::apm::PerformanceMode _0, OUT nn::apm::PerformanceConfiguration& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::apm::ISession::SetPerformanceConfiguration(IN nn::apm::PerformanceMode _0, IN nn::apm::PerformanceConfiguration _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::apm::ISystemManager::ClearLastThrottlingState() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::apm::ISystemManager::GetLastThrottlingState(OUT nn::apm::ThrottlingState& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::apm::ISystemManager::GetPerformanceEvent(IN nn::apm::EventTarget _0, OUT KObject * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::apm::ISystemManager::GetThrottlingState(OUT nn::apm::ThrottlingState& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::apm::ISystemManager::RequestPerformanceMode(IN nn::apm::PerformanceMode _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::arp::detail { + class IReader { + public: + IReader(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + uint32_t Unknown3(); + }; + class IRegistrar { + public: + IRegistrar(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + }; + class IWriter { + public: + IWriter(); + uint32_t Unknown0(); + uint32_t Unknown1(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::arp::detail::IReader::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::arp::detail::IReader::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::arp::detail::IReader::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::arp::detail::IReader::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::arp::detail::IRegistrar::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::arp::detail::IRegistrar::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::arp::detail::IRegistrar::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::arp::detail::IWriter::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::arp::detail::IWriter::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::audio::detail { + class IAudioDebugManager { + public: + IAudioDebugManager(); + uint32_t Unknown0(IN uint32_t _0, IN uint64_t _1, IN KObject * _2); + uint32_t Unknown1(); + uint32_t Unknown2(); + uint32_t Unknown3(); + }; + class IAudioDevice { + public: + IAudioDevice(); + uint32_t Unknown0(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown1(IN uint32_t _0, IN uint8_t * _1, guint _1_size); + uint32_t Unknown10(OUT uint8_t * _0, guint _0_size); + uint32_t Unknown11(OUT KObject * _0); + uint32_t Unknown12(OUT KObject * _0); + uint32_t Unknown2(IN uint8_t * _0, guint _0_size, OUT uint32_t& _1); + uint32_t Unknown3(OUT uint8_t * _0, guint _0_size); + uint32_t Unknown4(OUT KObject * _0); + uint32_t Unknown5(OUT uint32_t& _0); + uint32_t Unknown6(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown7(IN uint32_t _0, IN uint8_t * _1, guint _1_size); + uint32_t Unknown8(IN uint8_t * _0, guint _0_size, OUT uint32_t& _1); + }; + class IAudioIn { + public: + IAudioIn(); + uint32_t Unknown0(OUT uint32_t& _0); + uint32_t Unknown1(); + uint32_t Unknown10(IN uint64_t _0, IN KObject * _1, IN uint8_t * _2, guint _2_size); + uint32_t Unknown2(); + uint32_t Unknown3(IN uint64_t _0, IN uint8_t * _1, guint _1_size); + uint32_t Unknown4(OUT KObject * _0); + uint32_t Unknown5(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown6(IN uint64_t _0, OUT uint8_t& _1); + uint32_t Unknown7(IN uint64_t _0, IN KObject * _1, IN uint8_t * _2, guint _2_size); + uint32_t Unknown8(IN uint64_t _0, IN uint8_t * _1, guint _1_size); + uint32_t Unknown9(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size); + }; + class IAudioInManager { + public: + IAudioInManager(); + uint32_t Unknown0(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown1(IN uint64_t _0, IN uint64_t _1, IN gpid _2, IN KObject * _3, IN uint8_t * _4, guint _4_size, OUT uint128_t& _5, OUT IUnknown * _6, OUT uint8_t * _7, guint _7_size); + uint32_t Unknown2(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown3(IN uint64_t _0, IN uint64_t _1, IN gpid _2, IN KObject * _3, IN uint8_t * _4, guint _4_size, OUT uint128_t& _5, OUT IUnknown * _6, OUT uint8_t * _7, guint _7_size); + uint32_t Unknown4(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size); + }; + class IAudioInManagerForApplet { + public: + IAudioInManagerForApplet(); + uint32_t Unknown0(IN uint64_t _0, IN uint64_t _1, OUT KObject * _2); + uint32_t Unknown1(IN uint64_t _0, IN uint64_t _1, OUT KObject * _2); + uint32_t Unknown2(IN uint64_t _0, OUT uint32_t& _1); + uint32_t Unknown3(IN uint32_t _0, IN uint64_t _1, IN uint64_t _2); + }; + class IAudioInManagerForDebugger { + public: + IAudioInManagerForDebugger(); + uint32_t Unknown0(IN uint64_t _0); + uint32_t Unknown1(IN uint64_t _0); + }; + class IAudioOut { + public: + IAudioOut(); + uint32_t Unknown0(OUT uint32_t& _0); + uint32_t Unknown1(); + uint32_t Unknown2(); + uint32_t Unknown3(IN uint64_t _0, IN uint8_t * _1, guint _1_size); + uint32_t Unknown4(OUT KObject * _0); + uint32_t Unknown5(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown6(IN uint64_t _0, OUT uint8_t& _1); + uint32_t Unknown7(IN uint64_t _0, IN uint8_t * _1, guint _1_size); + uint32_t Unknown8(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size); + }; + class IAudioOutManager { + public: + IAudioOutManager(); + uint32_t Unknown0(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown1(IN uint64_t _0, IN uint64_t _1, IN gpid _2, IN KObject * _3, IN uint8_t * _4, guint _4_size, OUT uint128_t& _5, OUT IUnknown * _6, OUT uint8_t * _7, guint _7_size); + uint32_t Unknown2(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown3(IN uint64_t _0, IN uint64_t _1, IN gpid _2, IN KObject * _3, IN uint8_t * _4, guint _4_size, OUT uint128_t& _5, OUT IUnknown * _6, OUT uint8_t * _7, guint _7_size); + }; + class IAudioOutManagerForApplet { + public: + IAudioOutManagerForApplet(); + uint32_t Unknown0(IN uint64_t _0, IN uint64_t _1, OUT KObject * _2); + uint32_t Unknown1(IN uint64_t _0, IN uint64_t _1, OUT KObject * _2); + uint32_t Unknown2(IN uint64_t _0, OUT uint32_t& _1); + uint32_t Unknown3(IN uint32_t _0, IN uint64_t _1, IN uint64_t _2); + }; + class IAudioOutManagerForDebugger { + public: + IAudioOutManagerForDebugger(); + uint32_t Unknown0(IN uint64_t _0); + uint32_t Unknown1(IN uint64_t _0); + }; + class IAudioRenderer { + public: + IAudioRenderer(); + uint32_t Unknown0(OUT uint32_t& _0); + uint32_t Unknown1(OUT uint32_t& _0); + uint32_t Unknown10(IN uint8_t * _0, guint _0_size, OUT uint8_t * _1, guint _1_size, OUT uint8_t * _2, guint _2_size); + uint32_t Unknown11(); + uint32_t Unknown2(OUT uint32_t& _0); + uint32_t Unknown3(OUT uint32_t& _0); + uint32_t Unknown4(IN uint8_t * _0, guint _0_size, OUT uint8_t * _1, guint _1_size, OUT uint8_t * _2, guint _2_size); + uint32_t Unknown5(); + uint32_t Unknown6(); + uint32_t Unknown7(OUT KObject * _0); + uint32_t Unknown8(IN uint32_t _0); + uint32_t Unknown9(OUT uint32_t& _0); + }; + class IAudioRendererManager { + public: + IAudioRendererManager(); + uint32_t Unknown0(IN uint8_t * _0, IN uint64_t _1, IN uint64_t _2, IN gpid _3, IN KObject * _4, IN KObject * _5, OUT IUnknown * _6); + uint32_t Unknown1(IN uint8_t * _0, OUT uint64_t& _1); + uint32_t Unknown2(IN uint64_t _0, OUT IUnknown * _1); + uint32_t Unknown3(IN uint8_t * _0, IN uint64_t _1, IN uint64_t _2, IN uint64_t _3, IN gpid _4, IN KObject * _5, OUT IUnknown * _6); + }; + class IAudioRendererManagerForApplet { + public: + IAudioRendererManagerForApplet(); + uint32_t Unknown0(IN uint64_t _0, IN uint64_t _1, OUT KObject * _2); + uint32_t Unknown1(IN uint64_t _0, IN uint64_t _1, OUT KObject * _2); + uint32_t Unknown2(IN uint64_t _0, OUT uint32_t& _1); + uint32_t Unknown3(IN uint32_t _0, IN uint64_t _1, IN uint64_t _2); + uint32_t Unknown4(IN uint64_t _0); + uint32_t Unknown5(IN uint64_t _0); + }; + class IAudioRendererManagerForDebugger { + public: + IAudioRendererManagerForDebugger(); + uint32_t Unknown0(IN uint64_t _0); + uint32_t Unknown1(IN uint64_t _0); + }; + class IFinalOutputRecorder { + public: + IFinalOutputRecorder(); + uint32_t Unknown0(OUT uint32_t& _0); + uint32_t Unknown1(); + uint32_t Unknown2(); + uint32_t Unknown3(IN uint64_t _0, IN uint8_t * _1, guint _1_size); + uint32_t Unknown4(OUT KObject * _0); + uint32_t Unknown5(OUT uint32_t& _0, OUT uint64_t& _1, OUT uint8_t * _2, guint _2_size); + uint32_t Unknown6(IN uint64_t _0, OUT uint8_t& _1); + uint32_t Unknown7(IN uint64_t _0, OUT uint64_t& _1); + uint32_t Unknown8(IN uint64_t _0, IN uint8_t * _1, guint _1_size); + uint32_t Unknown9(OUT uint32_t& _0, OUT uint64_t& _1, OUT uint8_t * _2, guint _2_size); + }; + class IFinalOutputRecorderManager { + public: + IFinalOutputRecorderManager(); + uint32_t Unknown0(IN uint64_t _0, IN uint64_t _1, IN KObject * _2, OUT uint128_t& _3, OUT IUnknown * _4); + }; + class IFinalOutputRecorderManagerForApplet { + public: + IFinalOutputRecorderManagerForApplet(); + uint32_t Unknown0(IN uint64_t _0, IN uint64_t _1, OUT KObject * _2); + uint32_t Unknown1(IN uint64_t _0, IN uint64_t _1, OUT KObject * _2); + }; + class IFinalOutputRecorderManagerForDebugger { + public: + IFinalOutputRecorderManagerForDebugger(); + uint32_t Unknown0(IN uint64_t _0); + uint32_t Unknown1(IN uint64_t _0); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::audio::detail::IAudioDebugManager::Unknown0(IN uint32_t _0, IN uint64_t _1, IN KObject * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IAudioDebugManager::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IAudioDebugManager::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IAudioDebugManager::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IAudioDevice::Unknown0(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::audio::detail::IAudioDevice::Unknown1(IN uint32_t _0, IN uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::audio::detail::IAudioDevice::Unknown10(OUT uint8_t * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x22, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::audio::detail::IAudioDevice::Unknown11(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::audio::detail::IAudioDevice::Unknown12(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::audio::detail::IAudioDevice::Unknown2(IN uint8_t * _0, guint _0_size, OUT uint32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::audio::detail::IAudioDevice::Unknown3(OUT uint8_t * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::audio::detail::IAudioDevice::Unknown4(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::audio::detail::IAudioDevice::Unknown5(OUT uint32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IAudioDevice::Unknown6(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x22, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::audio::detail::IAudioDevice::Unknown7(IN uint32_t _0, IN uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x21, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::audio::detail::IAudioDevice::Unknown8(IN uint8_t * _0, guint _0_size, OUT uint32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x21, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::audio::detail::IAudioIn::Unknown0(OUT uint32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IAudioIn::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IAudioIn::Unknown10(IN uint64_t _0, IN KObject * _1, IN uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x21, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::audio::detail::IAudioIn::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IAudioIn::Unknown3(IN uint64_t _0, IN uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::audio::detail::IAudioIn::Unknown4(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::audio::detail::IAudioIn::Unknown5(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::audio::detail::IAudioIn::Unknown6(IN uint64_t _0, OUT uint8_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IAudioIn::Unknown7(IN uint64_t _0, IN KObject * _1, IN uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::audio::detail::IAudioIn::Unknown8(IN uint64_t _0, IN uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x21, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::audio::detail::IAudioIn::Unknown9(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x22, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::audio::detail::IAudioInManager::Unknown0(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::audio::detail::IAudioInManager::Unknown1(IN uint64_t _0, IN uint64_t _1, IN gpid _2, IN KObject * _3, IN uint8_t * _4, guint _4_size, OUT uint128_t& _5, OUT IUnknown * _6, OUT uint8_t * _7, guint _7_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(6, 0, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + _6 OMG = new IUnknown(resp.move_handles[0]); + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +uint32_t nn::audio::detail::IAudioInManager::Unknown2(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x22, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::audio::detail::IAudioInManager::Unknown3(IN uint64_t _0, IN uint64_t _1, IN gpid _2, IN KObject * _3, IN uint8_t * _4, guint _4_size, OUT uint128_t& _5, OUT IUnknown * _6, OUT uint8_t * _7, guint _7_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x21, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(0x22, 0, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + _6 OMG = new IUnknown(resp.move_handles[0]); + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +uint32_t nn::audio::detail::IAudioInManager::Unknown4(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x22, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::audio::detail::IAudioInManagerForApplet::Unknown0(IN uint64_t _0, IN uint64_t _1, OUT KObject * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::audio::detail::IAudioInManagerForApplet::Unknown1(IN uint64_t _0, IN uint64_t _1, OUT KObject * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::audio::detail::IAudioInManagerForApplet::Unknown2(IN uint64_t _0, OUT uint32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IAudioInManagerForApplet::Unknown3(IN uint32_t _0, IN uint64_t _1, IN uint64_t _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IAudioInManagerForDebugger::Unknown0(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IAudioInManagerForDebugger::Unknown1(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IAudioOut::Unknown0(OUT uint32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IAudioOut::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IAudioOut::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IAudioOut::Unknown3(IN uint64_t _0, IN uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::audio::detail::IAudioOut::Unknown4(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::audio::detail::IAudioOut::Unknown5(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::audio::detail::IAudioOut::Unknown6(IN uint64_t _0, OUT uint8_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IAudioOut::Unknown7(IN uint64_t _0, IN uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x21, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::audio::detail::IAudioOut::Unknown8(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x22, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::audio::detail::IAudioOutManager::Unknown0(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::audio::detail::IAudioOutManager::Unknown1(IN uint64_t _0, IN uint64_t _1, IN gpid _2, IN KObject * _3, IN uint8_t * _4, guint _4_size, OUT uint128_t& _5, OUT IUnknown * _6, OUT uint8_t * _7, guint _7_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(6, 0, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + _6 OMG = new IUnknown(resp.move_handles[0]); + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +uint32_t nn::audio::detail::IAudioOutManager::Unknown2(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x22, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::audio::detail::IAudioOutManager::Unknown3(IN uint64_t _0, IN uint64_t _1, IN gpid _2, IN KObject * _3, IN uint8_t * _4, guint _4_size, OUT uint128_t& _5, OUT IUnknown * _6, OUT uint8_t * _7, guint _7_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x21, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(0x22, 0, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + _6 OMG = new IUnknown(resp.move_handles[0]); + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +uint32_t nn::audio::detail::IAudioOutManagerForApplet::Unknown0(IN uint64_t _0, IN uint64_t _1, OUT KObject * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::audio::detail::IAudioOutManagerForApplet::Unknown1(IN uint64_t _0, IN uint64_t _1, OUT KObject * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::audio::detail::IAudioOutManagerForApplet::Unknown2(IN uint64_t _0, OUT uint32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IAudioOutManagerForApplet::Unknown3(IN uint32_t _0, IN uint64_t _1, IN uint64_t _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IAudioOutManagerForDebugger::Unknown0(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IAudioOutManagerForDebugger::Unknown1(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IAudioRenderer::Unknown0(OUT uint32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IAudioRenderer::Unknown1(OUT uint32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IAudioRenderer::Unknown10(IN uint8_t * _0, guint _0_size, OUT uint8_t * _1, guint _1_size, OUT uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x21, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(0x22, 0, temp5); + guint temp8; + auto temp7 = req.getBuffer(0x22, 1, temp8); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + ctu->cpu.writemem(temp7, temp9, temp8); + delete[] temp9; + return ret; +} +uint32_t nn::audio::detail::IAudioRenderer::Unknown11() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IAudioRenderer::Unknown2(OUT uint32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IAudioRenderer::Unknown3(OUT uint32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IAudioRenderer::Unknown4(IN uint8_t * _0, guint _0_size, OUT uint8_t * _1, guint _1_size, OUT uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(6, 0, temp5); + guint temp8; + auto temp7 = req.getBuffer(6, 1, temp8); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + ctu->cpu.writemem(temp7, temp9, temp8); + delete[] temp9; + return ret; +} +uint32_t nn::audio::detail::IAudioRenderer::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IAudioRenderer::Unknown6() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IAudioRenderer::Unknown7(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::audio::detail::IAudioRenderer::Unknown8(IN uint32_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IAudioRenderer::Unknown9(OUT uint32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IAudioRendererManager::Unknown0(IN uint8_t * _0, IN uint64_t _1, IN uint64_t _2, IN gpid _3, IN KObject * _4, IN KObject * _5, OUT IUnknown * _6) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _6 OMG = new IUnknown(resp.move_handles[0]); + return ret; +} +uint32_t nn::audio::detail::IAudioRendererManager::Unknown1(IN uint8_t * _0, OUT uint64_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IAudioRendererManager::Unknown2(IN uint64_t _0, OUT IUnknown * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new IUnknown(resp.move_handles[0]); + return ret; +} +uint32_t nn::audio::detail::IAudioRendererManager::Unknown3(IN uint8_t * _0, IN uint64_t _1, IN uint64_t _2, IN uint64_t _3, IN gpid _4, IN KObject * _5, OUT IUnknown * _6) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _6 OMG = new IUnknown(resp.move_handles[0]); + return ret; +} +uint32_t nn::audio::detail::IAudioRendererManagerForApplet::Unknown0(IN uint64_t _0, IN uint64_t _1, OUT KObject * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::audio::detail::IAudioRendererManagerForApplet::Unknown1(IN uint64_t _0, IN uint64_t _1, OUT KObject * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::audio::detail::IAudioRendererManagerForApplet::Unknown2(IN uint64_t _0, OUT uint32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IAudioRendererManagerForApplet::Unknown3(IN uint32_t _0, IN uint64_t _1, IN uint64_t _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IAudioRendererManagerForApplet::Unknown4(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IAudioRendererManagerForApplet::Unknown5(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IAudioRendererManagerForDebugger::Unknown0(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IAudioRendererManagerForDebugger::Unknown1(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IFinalOutputRecorder::Unknown0(OUT uint32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IFinalOutputRecorder::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IFinalOutputRecorder::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IFinalOutputRecorder::Unknown3(IN uint64_t _0, IN uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::audio::detail::IFinalOutputRecorder::Unknown4(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::audio::detail::IFinalOutputRecorder::Unknown5(OUT uint32_t& _0, OUT uint64_t& _1, OUT uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::audio::detail::IFinalOutputRecorder::Unknown6(IN uint64_t _0, OUT uint8_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IFinalOutputRecorder::Unknown7(IN uint64_t _0, OUT uint64_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IFinalOutputRecorder::Unknown8(IN uint64_t _0, IN uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x21, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::audio::detail::IFinalOutputRecorder::Unknown9(OUT uint32_t& _0, OUT uint64_t& _1, OUT uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x22, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::audio::detail::IFinalOutputRecorderManager::Unknown0(IN uint64_t _0, IN uint64_t _1, IN KObject * _2, OUT uint128_t& _3, OUT IUnknown * _4) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _4 OMG = new IUnknown(resp.move_handles[0]); + return ret; +} +uint32_t nn::audio::detail::IFinalOutputRecorderManagerForApplet::Unknown0(IN uint64_t _0, IN uint64_t _1, OUT KObject * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::audio::detail::IFinalOutputRecorderManagerForApplet::Unknown1(IN uint64_t _0, IN uint64_t _1, OUT KObject * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::audio::detail::IFinalOutputRecorderManagerForDebugger::Unknown0(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audio::detail::IFinalOutputRecorderManagerForDebugger::Unknown1(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::audioctrl::detail { + class IAudioController { + public: + IAudioController(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown10(); + uint32_t Unknown11(); + uint32_t Unknown12(); + uint32_t Unknown13(); + uint32_t Unknown14(); + uint32_t Unknown15(); + uint32_t Unknown16(); + uint32_t Unknown17(); + uint32_t Unknown18(); + uint32_t Unknown19(); + uint32_t Unknown2(); + uint32_t Unknown20(); + uint32_t Unknown21(); + uint32_t Unknown22(); + uint32_t Unknown3(); + uint32_t Unknown4(); + uint32_t Unknown5(); + uint32_t Unknown6(); + uint32_t Unknown7(); + uint32_t Unknown8(); + uint32_t Unknown9(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::audioctrl::detail::IAudioController::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audioctrl::detail::IAudioController::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audioctrl::detail::IAudioController::Unknown10() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audioctrl::detail::IAudioController::Unknown11() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audioctrl::detail::IAudioController::Unknown12() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audioctrl::detail::IAudioController::Unknown13() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audioctrl::detail::IAudioController::Unknown14() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audioctrl::detail::IAudioController::Unknown15() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audioctrl::detail::IAudioController::Unknown16() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audioctrl::detail::IAudioController::Unknown17() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audioctrl::detail::IAudioController::Unknown18() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audioctrl::detail::IAudioController::Unknown19() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audioctrl::detail::IAudioController::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audioctrl::detail::IAudioController::Unknown20() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audioctrl::detail::IAudioController::Unknown21() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audioctrl::detail::IAudioController::Unknown22() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audioctrl::detail::IAudioController::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audioctrl::detail::IAudioController::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audioctrl::detail::IAudioController::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audioctrl::detail::IAudioController::Unknown6() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audioctrl::detail::IAudioController::Unknown7() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audioctrl::detail::IAudioController::Unknown8() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::audioctrl::detail::IAudioController::Unknown9() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::bcat::detail::ipc { + class IBcatService { + public: + IBcatService(); + uint32_t BlockDeliveryTask(IN nn::ApplicationId _0); + uint32_t ClearDeliveryCacheStorage(IN nn::ApplicationId _0); + uint32_t EnumerateBackgroundDeliveryTask(OUT int32_t& _0, OUT nn::bcat::TaskInfo * _1, guint _1_size); + uint32_t GetDeliveryList(IN nn::ApplicationId _0, OUT uint64_t& _1, OUT uint8_t * _2, guint _2_size); + uint32_t GetPushNotificationLog(OUT int32_t& _0, OUT nn::bcat::PushNotificationLog * _1, guint _1_size); + uint32_t RegisterBackgroundDeliveryTask(IN uint32_t _0, IN nn::ApplicationId _1); + uint32_t RequestSyncDeliveryCache(OUT nn::bcat::detail::ipc::IDeliveryCacheProgressService * _0); + uint32_t RequestSyncDeliveryCacheWithApplicationId(IN uint32_t _0, IN nn::ApplicationId _1, OUT nn::bcat::detail::ipc::IDeliveryCacheProgressService * _2); + uint32_t SetPassphrase(IN nn::ApplicationId _0, IN int8_t * _1, guint _1_size); + uint32_t UnblockDeliveryTask(IN nn::ApplicationId _0); + uint32_t UnregisterBackgroundDeliveryTask(IN nn::ApplicationId _0); + }; + class IDeliveryCacheDirectoryService { + public: + IDeliveryCacheDirectoryService(); + uint32_t GetCount(OUT int32_t& _0); + uint32_t Open(IN nn::bcat::DirectoryName _0); + uint32_t Read(OUT int32_t& _0, OUT nn::bcat::DeliveryCacheDirectoryEntry * _1, guint _1_size); + }; + class IDeliveryCacheFileService { + public: + IDeliveryCacheFileService(); + uint32_t GetDigest(OUT nn::bcat::Digest& _0); + uint32_t GetSize(OUT int64_t& _0); + uint32_t Open(IN nn::bcat::DirectoryName _0, IN nn::bcat::FileName _1); + uint32_t Read(IN int64_t _0, OUT uint64_t& _1, OUT uint8_t * _2, guint _2_size); + }; + class IDeliveryCacheProgressService { + public: + IDeliveryCacheProgressService(); + uint32_t GetEvent(OUT KObject * _0); + uint32_t GetImpl(OUT nn::bcat::detail::DeliveryCacheProgressImpl * _0, guint _0_size); + }; + class IDeliveryCacheStorageService { + public: + IDeliveryCacheStorageService(); + uint32_t CreateDirectoryService(OUT nn::bcat::detail::ipc::IDeliveryCacheDirectoryService * _0); + uint32_t CreateFileService(OUT nn::bcat::detail::ipc::IDeliveryCacheFileService * _0); + uint32_t EnumerateDeliveryCacheDirectory(OUT int32_t& _0, OUT nn::bcat::DirectoryName * _1, guint _1_size); + }; + class IServiceCreator { + public: + IServiceCreator(); + uint32_t CreateBcatService(IN uint64_t _0, IN gpid _1, OUT nn::bcat::detail::ipc::IBcatService * _2); + uint32_t CreateDeliveryCacheStorageService(IN uint64_t _0, IN gpid _1, OUT nn::bcat::detail::ipc::IDeliveryCacheStorageService * _2); + uint32_t CreateDeliveryCacheStorageServiceWithApplicationId(IN nn::ApplicationId _0, OUT nn::bcat::detail::ipc::IDeliveryCacheStorageService * _1); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::bcat::detail::ipc::IBcatService::BlockDeliveryTask(IN nn::ApplicationId _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bcat::detail::ipc::IBcatService::ClearDeliveryCacheStorage(IN nn::ApplicationId _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bcat::detail::ipc::IBcatService::EnumerateBackgroundDeliveryTask(OUT int32_t& _0, OUT nn::bcat::TaskInfo * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::bcat::detail::ipc::IBcatService::GetDeliveryList(IN nn::ApplicationId _0, OUT uint64_t& _1, OUT uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::bcat::detail::ipc::IBcatService::GetPushNotificationLog(OUT int32_t& _0, OUT nn::bcat::PushNotificationLog * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::bcat::detail::ipc::IBcatService::RegisterBackgroundDeliveryTask(IN uint32_t _0, IN nn::ApplicationId _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bcat::detail::ipc::IBcatService::RequestSyncDeliveryCache(OUT nn::bcat::detail::ipc::IDeliveryCacheProgressService * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::bcat::detail::ipc::IDeliveryCacheProgressService(resp.move_handles[0]); + return ret; +} +uint32_t nn::bcat::detail::ipc::IBcatService::RequestSyncDeliveryCacheWithApplicationId(IN uint32_t _0, IN nn::ApplicationId _1, OUT nn::bcat::detail::ipc::IDeliveryCacheProgressService * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _2 OMG = new nn::bcat::detail::ipc::IDeliveryCacheProgressService(resp.move_handles[0]); + return ret; +} +uint32_t nn::bcat::detail::ipc::IBcatService::SetPassphrase(IN nn::ApplicationId _0, IN int8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(9, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::bcat::detail::ipc::IBcatService::UnblockDeliveryTask(IN nn::ApplicationId _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bcat::detail::ipc::IBcatService::UnregisterBackgroundDeliveryTask(IN nn::ApplicationId _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bcat::detail::ipc::IDeliveryCacheDirectoryService::GetCount(OUT int32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bcat::detail::ipc::IDeliveryCacheDirectoryService::Open(IN nn::bcat::DirectoryName _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bcat::detail::ipc::IDeliveryCacheDirectoryService::Read(OUT int32_t& _0, OUT nn::bcat::DeliveryCacheDirectoryEntry * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::bcat::detail::ipc::IDeliveryCacheFileService::GetDigest(OUT nn::bcat::Digest& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bcat::detail::ipc::IDeliveryCacheFileService::GetSize(OUT int64_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bcat::detail::ipc::IDeliveryCacheFileService::Open(IN nn::bcat::DirectoryName _0, IN nn::bcat::FileName _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bcat::detail::ipc::IDeliveryCacheFileService::Read(IN int64_t _0, OUT uint64_t& _1, OUT uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::bcat::detail::ipc::IDeliveryCacheProgressService::GetEvent(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::bcat::detail::ipc::IDeliveryCacheProgressService::GetImpl(OUT nn::bcat::detail::DeliveryCacheProgressImpl * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::bcat::detail::ipc::IDeliveryCacheStorageService::CreateDirectoryService(OUT nn::bcat::detail::ipc::IDeliveryCacheDirectoryService * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::bcat::detail::ipc::IDeliveryCacheDirectoryService(resp.move_handles[0]); + return ret; +} +uint32_t nn::bcat::detail::ipc::IDeliveryCacheStorageService::CreateFileService(OUT nn::bcat::detail::ipc::IDeliveryCacheFileService * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::bcat::detail::ipc::IDeliveryCacheFileService(resp.move_handles[0]); + return ret; +} +uint32_t nn::bcat::detail::ipc::IDeliveryCacheStorageService::EnumerateDeliveryCacheDirectory(OUT int32_t& _0, OUT nn::bcat::DirectoryName * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::bcat::detail::ipc::IServiceCreator::CreateBcatService(IN uint64_t _0, IN gpid _1, OUT nn::bcat::detail::ipc::IBcatService * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _2 OMG = new nn::bcat::detail::ipc::IBcatService(resp.move_handles[0]); + return ret; +} +uint32_t nn::bcat::detail::ipc::IServiceCreator::CreateDeliveryCacheStorageService(IN uint64_t _0, IN gpid _1, OUT nn::bcat::detail::ipc::IDeliveryCacheStorageService * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _2 OMG = new nn::bcat::detail::ipc::IDeliveryCacheStorageService(resp.move_handles[0]); + return ret; +} +uint32_t nn::bcat::detail::ipc::IServiceCreator::CreateDeliveryCacheStorageServiceWithApplicationId(IN nn::ApplicationId _0, OUT nn::bcat::detail::ipc::IDeliveryCacheStorageService * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new nn::bcat::detail::ipc::IDeliveryCacheStorageService(resp.move_handles[0]); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::bgtc { + class IStateControlService { + public: + IStateControlService(); + }; + class ITaskService { + public: + ITaskService(); + uint32_t Unknown14(OUT KObject * _0); + uint32_t Unknown3(OUT KObject * _0); + uint32_t Unknown5(IN uint8_t * _0, guint _0_size); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::bgtc::ITaskService::Unknown14(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::bgtc::ITaskService::Unknown3(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::bgtc::ITaskService::Unknown5(IN uint8_t * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(9, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::bluetooth { + class IBluetoothDriver { + public: + IBluetoothDriver(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown10(); + uint32_t Unknown11(); + uint32_t Unknown12(); + uint32_t Unknown13(); + uint32_t Unknown14(); + uint32_t Unknown15(); + uint32_t Unknown16(); + uint32_t Unknown17(); + uint32_t Unknown18(); + uint32_t Unknown19(); + uint32_t Unknown2(); + uint32_t Unknown20(); + uint32_t Unknown21(); + uint32_t Unknown22(); + uint32_t Unknown23(); + uint32_t Unknown24(); + uint32_t Unknown25(); + uint32_t Unknown26(); + uint32_t Unknown27(); + uint32_t Unknown28(); + uint32_t Unknown29(); + uint32_t Unknown3(); + uint32_t Unknown30(); + uint32_t Unknown31(); + uint32_t Unknown32(); + uint32_t Unknown33(); + uint32_t Unknown34(); + uint32_t Unknown35(); + uint32_t Unknown36(); + uint32_t Unknown37(); + uint32_t Unknown38(); + uint32_t Unknown39(); + uint32_t Unknown4(); + uint32_t Unknown40(); + uint32_t Unknown41(); + uint32_t Unknown42(); + uint32_t Unknown43(); + uint32_t Unknown44(); + uint32_t Unknown5(); + uint32_t Unknown6(); + uint32_t Unknown7(); + uint32_t Unknown8(); + uint32_t Unknown9(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::bluetooth::IBluetoothDriver::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown10() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown11() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown12() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown13() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown14() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown15() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown16() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown17() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown18() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown19() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown20() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown21() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown22() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown23() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown24() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown25() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown26() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown27() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown28() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown29() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown30() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown31() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown32() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown33() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown34() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown35() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown36() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown37() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown38() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown39() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown40() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown41() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown42() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown43() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown44() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown6() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown7() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown8() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bluetooth::IBluetoothDriver::Unknown9() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::bpc { + class IBoardPowerControlManager { + public: + IBoardPowerControlManager(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown10(); + uint32_t Unknown11(); + uint32_t Unknown12(); + uint32_t Unknown13(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + uint32_t Unknown5(); + uint32_t Unknown6(); + uint32_t Unknown7(); + uint32_t Unknown8(); + uint32_t Unknown9(); + }; + class IRtcManager { + public: + IRtcManager(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::bpc::IBoardPowerControlManager::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bpc::IBoardPowerControlManager::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bpc::IBoardPowerControlManager::Unknown10() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bpc::IBoardPowerControlManager::Unknown11() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bpc::IBoardPowerControlManager::Unknown12() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bpc::IBoardPowerControlManager::Unknown13() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bpc::IBoardPowerControlManager::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bpc::IBoardPowerControlManager::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bpc::IBoardPowerControlManager::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bpc::IBoardPowerControlManager::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bpc::IBoardPowerControlManager::Unknown6() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bpc::IBoardPowerControlManager::Unknown7() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bpc::IBoardPowerControlManager::Unknown8() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bpc::IBoardPowerControlManager::Unknown9() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bpc::IRtcManager::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bpc::IRtcManager::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bpc::IRtcManager::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bpc::IRtcManager::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bpc::IRtcManager::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::bsdsocket::cfg { + class ServerInterface { + public: + ServerInterface(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown10(); + uint32_t Unknown11(); + uint32_t Unknown12(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + uint32_t Unknown5(); + uint32_t Unknown6(); + uint32_t Unknown7(); + uint32_t Unknown8(); + uint32_t Unknown9(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::bsdsocket::cfg::ServerInterface::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bsdsocket::cfg::ServerInterface::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bsdsocket::cfg::ServerInterface::Unknown10() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bsdsocket::cfg::ServerInterface::Unknown11() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bsdsocket::cfg::ServerInterface::Unknown12() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bsdsocket::cfg::ServerInterface::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bsdsocket::cfg::ServerInterface::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bsdsocket::cfg::ServerInterface::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bsdsocket::cfg::ServerInterface::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bsdsocket::cfg::ServerInterface::Unknown6() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bsdsocket::cfg::ServerInterface::Unknown7() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bsdsocket::cfg::ServerInterface::Unknown8() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::bsdsocket::cfg::ServerInterface::Unknown9() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::btm { + class IBtm { + public: + IBtm(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown10(); + uint32_t Unknown11(); + uint32_t Unknown12(); + uint32_t Unknown13(); + uint32_t Unknown14(); + uint32_t Unknown15(); + uint32_t Unknown16(); + uint32_t Unknown17(); + uint32_t Unknown18(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + uint32_t Unknown5(); + uint32_t Unknown6(); + uint32_t Unknown7(); + uint32_t Unknown8(); + uint32_t Unknown9(); + }; + class IBtmDebug { + public: + IBtmDebug(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + uint32_t Unknown5(); + uint32_t Unknown6(); + uint32_t Unknown7(); + uint32_t Unknown8(); + }; + class IBtmSystem { + public: + IBtmSystem(); + uint32_t Unknown0(); + }; + class IBtmSystemCore { + public: + IBtmSystemCore(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + uint32_t Unknown5(); + uint32_t Unknown6(); + uint32_t Unknown7(); + uint32_t Unknown8(); + uint32_t Unknown9(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::btm::IBtm::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::btm::IBtm::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::btm::IBtm::Unknown10() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::btm::IBtm::Unknown11() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::btm::IBtm::Unknown12() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::btm::IBtm::Unknown13() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::btm::IBtm::Unknown14() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::btm::IBtm::Unknown15() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::btm::IBtm::Unknown16() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::btm::IBtm::Unknown17() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::btm::IBtm::Unknown18() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::btm::IBtm::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::btm::IBtm::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::btm::IBtm::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::btm::IBtm::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::btm::IBtm::Unknown6() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::btm::IBtm::Unknown7() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::btm::IBtm::Unknown8() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::btm::IBtm::Unknown9() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::btm::IBtmDebug::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::btm::IBtmDebug::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::btm::IBtmDebug::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::btm::IBtmDebug::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::btm::IBtmDebug::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::btm::IBtmDebug::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::btm::IBtmDebug::Unknown6() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::btm::IBtmDebug::Unknown7() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::btm::IBtmDebug::Unknown8() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::btm::IBtmSystem::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::btm::IBtmSystemCore::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::btm::IBtmSystemCore::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::btm::IBtmSystemCore::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::btm::IBtmSystemCore::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::btm::IBtmSystemCore::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::btm::IBtmSystemCore::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::btm::IBtmSystemCore::Unknown6() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::btm::IBtmSystemCore::Unknown7() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::btm::IBtmSystemCore::Unknown8() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::btm::IBtmSystemCore::Unknown9() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::capsrv::sf { + class IAlbumAccessorService { + public: + IAlbumAccessorService(); + }; + class IAlbumControlService { + public: + IAlbumControlService(); + }; + class IScreenShotApplicationService { + public: + IScreenShotApplicationService(); + uint32_t SaveScreenShot(IN uint32_t _0, IN uint32_t _1, IN nn::applet::AppletResourceUserId _2, IN gpid _3, IN uint8_t * _4, guint _4_size, OUT nn::capsrv::ApplicationAlbumEntry& _5); + uint32_t SaveScreenShotEx0(IN nn::capsrv::detail::ScreenShotAttributeEx0 _0, IN uint32_t _1, IN nn::applet::AppletResourceUserId _2, IN gpid _3, IN uint8_t * _4, guint _4_size, OUT nn::capsrv::ApplicationAlbumEntry& _5); + }; + class IScreenShotControlService { + public: + IScreenShotControlService(); + uint32_t Unknown1(); + uint32_t Unknown1001(); + uint32_t Unknown1002(); + uint32_t Unknown1003(); + uint32_t Unknown1011(); + uint32_t Unknown1012(); + uint32_t Unknown1201(); + uint32_t Unknown1202(); + uint32_t Unknown1203(); + uint32_t Unknown2(); + }; + class IScreenShotService { + public: + IScreenShotService(); + uint32_t Unknown201(); + uint32_t Unknown202(); + uint32_t Unknown203(); + uint32_t Unknown204(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::capsrv::sf::IScreenShotApplicationService::SaveScreenShot(IN uint32_t _0, IN uint32_t _1, IN nn::applet::AppletResourceUserId _2, IN gpid _3, IN uint8_t * _4, guint _4_size, OUT nn::capsrv::ApplicationAlbumEntry& _5) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x45, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto temp4 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::capsrv::sf::IScreenShotApplicationService::SaveScreenShotEx0(IN nn::capsrv::detail::ScreenShotAttributeEx0 _0, IN uint32_t _1, IN nn::applet::AppletResourceUserId _2, IN gpid _3, IN uint8_t * _4, guint _4_size, OUT nn::capsrv::ApplicationAlbumEntry& _5) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x45, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto temp4 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::capsrv::sf::IScreenShotControlService::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::capsrv::sf::IScreenShotControlService::Unknown1001() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::capsrv::sf::IScreenShotControlService::Unknown1002() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::capsrv::sf::IScreenShotControlService::Unknown1003() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::capsrv::sf::IScreenShotControlService::Unknown1011() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::capsrv::sf::IScreenShotControlService::Unknown1012() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::capsrv::sf::IScreenShotControlService::Unknown1201() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::capsrv::sf::IScreenShotControlService::Unknown1202() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::capsrv::sf::IScreenShotControlService::Unknown1203() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::capsrv::sf::IScreenShotControlService::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::capsrv::sf::IScreenShotService::Unknown201() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::capsrv::sf::IScreenShotService::Unknown202() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::capsrv::sf::IScreenShotService::Unknown203() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::capsrv::sf::IScreenShotService::Unknown204() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::cec { + class ICecManager { + public: + ICecManager(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + uint32_t Unknown5(); + uint32_t Unknown6(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::cec::ICecManager::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::cec::ICecManager::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::cec::ICecManager::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::cec::ICecManager::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::cec::ICecManager::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::cec::ICecManager::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::cec::ICecManager::Unknown6() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::codec::detail { + class IHardwareOpusDecoder { + public: + IHardwareOpusDecoder(); + uint32_t Unknown0(IN uint8_t * _0, guint _0_size, OUT uint32_t& _1, OUT uint32_t& _2, OUT uint8_t * _3, guint _3_size); + uint32_t Unknown1(IN uint8_t * _0, guint _0_size); + uint32_t Unknown2(IN uint8_t * _0, guint _0_size, OUT uint32_t& _1, OUT uint32_t& _2, OUT uint8_t * _3, guint _3_size); + uint32_t Unknown3(IN uint8_t * _0, guint _0_size); + }; + class IHardwareOpusDecoderManager { + public: + IHardwareOpusDecoderManager(); + uint32_t Unknown0(IN uint64_t _0, IN uint32_t _1, IN KObject * _2, OUT IUnknown * _3); + uint32_t Unknown1(IN uint64_t _0, OUT uint32_t& _1); + uint32_t Unknown2(IN uint32_t _0, IN KObject * _1, IN uint8_t * _2, guint _2_size, OUT IUnknown * _3); + uint32_t Unknown3(IN uint8_t * _0, guint _0_size, OUT uint32_t& _1); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::codec::detail::IHardwareOpusDecoder::Unknown0(IN uint8_t * _0, guint _0_size, OUT uint32_t& _1, OUT uint32_t& _2, OUT uint8_t * _3, guint _3_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(6, 0, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +uint32_t nn::codec::detail::IHardwareOpusDecoder::Unknown1(IN uint8_t * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::codec::detail::IHardwareOpusDecoder::Unknown2(IN uint8_t * _0, guint _0_size, OUT uint32_t& _1, OUT uint32_t& _2, OUT uint8_t * _3, guint _3_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(6, 0, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +uint32_t nn::codec::detail::IHardwareOpusDecoder::Unknown3(IN uint8_t * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::codec::detail::IHardwareOpusDecoderManager::Unknown0(IN uint64_t _0, IN uint32_t _1, IN KObject * _2, OUT IUnknown * _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _3 OMG = new IUnknown(resp.move_handles[0]); + return ret; +} +uint32_t nn::codec::detail::IHardwareOpusDecoderManager::Unknown1(IN uint64_t _0, OUT uint32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::codec::detail::IHardwareOpusDecoderManager::Unknown2(IN uint32_t _0, IN KObject * _1, IN uint8_t * _2, guint _2_size, OUT IUnknown * _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + _3 OMG = new IUnknown(resp.move_handles[0]); + return ret; +} +uint32_t nn::codec::detail::IHardwareOpusDecoderManager::Unknown3(IN uint8_t * _0, guint _0_size, OUT uint32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::erpt::sf { + class IContext { + public: + IContext(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + uint32_t Unknown5(); + }; + class IManager { + public: + IManager(); + uint32_t Unknown0(); + uint32_t Unknown1(); + }; + class IReport { + public: + IReport(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + uint32_t Unknown5(); + }; + class ISession { + public: + ISession(); + uint32_t Unknown0(); + uint32_t Unknown1(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::erpt::sf::IContext::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::erpt::sf::IContext::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::erpt::sf::IContext::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::erpt::sf::IContext::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::erpt::sf::IContext::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::erpt::sf::IContext::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::erpt::sf::IManager::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::erpt::sf::IManager::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::erpt::sf::IReport::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::erpt::sf::IReport::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::erpt::sf::IReport::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::erpt::sf::IReport::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::erpt::sf::IReport::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::erpt::sf::IReport::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::erpt::sf::ISession::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::erpt::sf::ISession::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::es { + class IETicketService { + public: + IETicketService(); + }; +} +#ifdef DEFINE_CALLERS +#endif // DEFINE_CALLERS +namespace nn::eth::sf { + class IEthInterface { + public: + IEthInterface(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + uint32_t Unknown5(); + }; + class IEthInterfaceGroup { + public: + IEthInterfaceGroup(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::eth::sf::IEthInterface::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::eth::sf::IEthInterface::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::eth::sf::IEthInterface::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::eth::sf::IEthInterface::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::eth::sf::IEthInterface::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::eth::sf::IEthInterface::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::eth::sf::IEthInterfaceGroup::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::eth::sf::IEthInterfaceGroup::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::eth::sf::IEthInterfaceGroup::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::eth::sf::IEthInterfaceGroup::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::eth::sf::IEthInterfaceGroup::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::eupld::sf { + class IControl { + public: + IControl(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + uint32_t Unknown3(); + }; + class IRequest { + public: + IRequest(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + uint32_t Unknown5(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::eupld::sf::IControl::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::eupld::sf::IControl::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::eupld::sf::IControl::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::eupld::sf::IControl::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::eupld::sf::IRequest::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::eupld::sf::IRequest::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::eupld::sf::IRequest::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::eupld::sf::IRequest::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::eupld::sf::IRequest::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::eupld::sf::IRequest::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::fan::detail { + class IController { + public: + IController(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + uint32_t Unknown5(); + uint32_t Unknown6(); + uint32_t Unknown7(); + }; + class IManager { + public: + IManager(); + uint32_t Unknown0(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::fan::detail::IController::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fan::detail::IController::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fan::detail::IController::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fan::detail::IController::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fan::detail::IController::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fan::detail::IController::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fan::detail::IController::Unknown6() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fan::detail::IController::Unknown7() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fan::detail::IManager::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::fatalsrv { + class IPrivateService { + public: + IPrivateService(); + uint32_t Unknown0(); + }; + class IService { + public: + IService(); + uint32_t TransitionToFatalError(IN uint64_t errorCode, IN uint64_t _1, IN uint8_t * errorBuf, guint errorBuf_size, IN gpid _3); + uint32_t Unknown0(IN uint64_t _0, IN uint64_t _1, IN gpid _2); + uint32_t Unknown1(IN uint64_t _0, IN uint64_t _1, IN gpid _2); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::fatalsrv::IPrivateService::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fatalsrv::IService::TransitionToFatalError(IN uint64_t errorCode, IN uint64_t _1, IN uint8_t * errorBuf, guint errorBuf_size, IN gpid _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x15, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::fatalsrv::IService::Unknown0(IN uint64_t _0, IN uint64_t _1, IN gpid _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fatalsrv::IService::Unknown1(IN uint64_t _0, IN uint64_t _1, IN gpid _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::fgm::sf { + class IDebugger { + public: + IDebugger(); + uint32_t Cancel(); + uint32_t Initialize(IN uint64_t _0, IN KObject * _1, OUT KObject * _2); + uint32_t Read(OUT uint32_t& _0, OUT uint32_t& _1, OUT uint32_t& _2, OUT uint8_t * _3, guint _3_size); + }; + class IRequest { + public: + IRequest(); + uint32_t Cancel(); + uint32_t Get(OUT uint32_t& _0); + uint32_t Initialize(IN nn::fgm::Module _0, IN uint64_t _1, IN gpid _2, OUT KObject * _3); + uint32_t Set(IN uint32_t _0, IN uint32_t _1); + }; + class ISession { + public: + ISession(); + uint32_t Initialize(OUT nn::fgm::sf::IRequest * _0); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::fgm::sf::IDebugger::Cancel() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fgm::sf::IDebugger::Initialize(IN uint64_t _0, IN KObject * _1, OUT KObject * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::fgm::sf::IDebugger::Read(OUT uint32_t& _0, OUT uint32_t& _1, OUT uint32_t& _2, OUT uint8_t * _3, guint _3_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::fgm::sf::IRequest::Cancel() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fgm::sf::IRequest::Get(OUT uint32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fgm::sf::IRequest::Initialize(IN nn::fgm::Module _0, IN uint64_t _1, IN gpid _2, OUT KObject * _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::fgm::sf::IRequest::Set(IN uint32_t _0, IN uint32_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fgm::sf::ISession::Initialize(OUT nn::fgm::sf::IRequest * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::fgm::sf::IRequest(resp.move_handles[0]); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::friends::detail::ipc { + class IFriendService { + public: + IFriendService(); + uint32_t AcceptFriendRequest(IN nn::account::Uid _0, IN nn::friends::RequestId _1); + uint32_t AddFacedFriendRequest(IN nn::friends::FacedFriendRequestRegistrationKey _0, IN nn::account::Nickname _1, IN nn::account::Uid _2, IN uint8_t * _3, guint _3_size); + uint32_t AddFacedFriendRequestForApplication(IN nn::friends::FacedFriendRequestRegistrationKey _0, IN nn::account::Nickname _1, IN nn::account::Uid _2, IN uint64_t _3, IN gpid _4, IN uint8_t * _5, guint _5_size, IN nn::friends::InAppScreenName * _6, guint _6_size, IN nn::friends::InAppScreenName * _7, guint _7_size); + uint32_t AddPlayHistory(IN nn::account::Uid _0, IN uint64_t _1, IN gpid _2, IN nn::friends::PlayHistoryRegistrationKey * _3, guint _3_size, IN nn::friends::InAppScreenName * _4, guint _4_size, IN nn::friends::InAppScreenName * _5, guint _5_size); + uint32_t BlockUser(IN int32_t _0, IN nn::account::Uid _1, IN nn::account::NetworkServiceAccountId _2); + uint32_t BlockUserWithApplicationInfo(IN int32_t _0, IN nn::account::Uid _1, IN nn::account::NetworkServiceAccountId _2, IN nn::friends::ApplicationInfo _3, IN nn::friends::InAppScreenName * _4, guint _4_size); + uint32_t Cancel(); + uint32_t CancelFacedFriendRequest(IN nn::account::Uid _0, IN nn::account::NetworkServiceAccountId _1); + uint32_t CancelFriendRequest(IN nn::account::Uid _0, IN nn::friends::RequestId _1); + uint32_t ChangeFriendFavoriteFlag(IN bool _0, IN nn::account::Uid _1, IN nn::account::NetworkServiceAccountId _2); + uint32_t ChangeFriendOnlineNotificationFlag(IN bool _0, IN nn::account::Uid _1, IN nn::account::NetworkServiceAccountId _2); + uint32_t ChangeFriendRequestReception(IN bool _0, IN nn::account::Uid _1); + uint32_t ChangePlayLogPermission(IN int32_t _0, IN nn::account::Uid _1); + uint32_t ChangePresencePermission(IN int32_t _0, IN nn::account::Uid _1); + uint32_t ClearPlayLog(IN nn::account::Uid _0); + uint32_t DeclareCloseOnlinePlaySession(IN nn::account::Uid _0); + uint32_t DeclareOpenOnlinePlaySession(IN nn::account::Uid _0); + uint32_t DeleteFriend(IN nn::account::Uid _0, IN nn::account::NetworkServiceAccountId _1); + uint32_t DeleteNetworkServiceAccountCache(IN nn::account::Uid _0); + uint32_t DeletePlayHistory(IN nn::account::Uid _0); + uint32_t DropFriendNewlyFlag(IN nn::account::Uid _0, IN nn::account::NetworkServiceAccountId _1); + uint32_t DropFriendNewlyFlags(IN nn::account::Uid _0); + uint32_t GetBlockedUserList(IN int32_t _0, IN nn::account::Uid _1, OUT int32_t& _2, OUT nn::friends::detail::BlockedUserImpl * _3, guint _3_size); + uint32_t GetBlockedUserListIds(IN int32_t _0, IN nn::account::Uid _1, OUT int32_t& _2, OUT nn::account::NetworkServiceAccountId * _3, guint _3_size); + uint32_t GetCompletionEvent(OUT KObject * _0); + uint32_t GetExternalApplicationCatalog(IN nn::settings::LanguageCode _0, IN nn::friends::ExternalApplicationCatalogId _1, OUT nn::friends::ExternalApplicationCatalog * _2, guint _2_size); + uint32_t GetFacedFriendRequestProfileImage(IN nn::account::Uid _0, IN nn::account::NetworkServiceAccountId _1, OUT int32_t& _2, OUT uint8_t * _3, guint _3_size); + uint32_t GetFacedFriendRequestProfileImageFromPath(IN int8_t * _0, guint _0_size, OUT int32_t& _1, OUT uint8_t * _2, guint _2_size); + uint32_t GetFacedFriendRequestRegistrationKey(IN nn::account::Uid _0, OUT nn::friends::FacedFriendRequestRegistrationKey& _1); + uint32_t GetFriendCandidateList(IN int32_t _0, IN nn::account::Uid _1, OUT int32_t& _2, OUT nn::friends::detail::FriendCandidateImpl * _3, guint _3_size); + uint32_t GetFriendCount(IN nn::account::Uid _0, IN nn::friends::detail::ipc::SizedFriendFilter _1, IN uint64_t _2, IN gpid _3, OUT int32_t& _4); + uint32_t GetFriendDetailedInfo(IN nn::account::Uid _0, IN nn::account::NetworkServiceAccountId _1, OUT nn::friends::detail::FriendDetailedInfoImpl * _2, guint _2_size); + uint32_t GetFriendList(IN int32_t _0, IN nn::account::Uid _1, IN nn::friends::detail::ipc::SizedFriendFilter _2, IN uint64_t _3, IN gpid _4, OUT int32_t& _5, OUT nn::friends::detail::FriendImpl * _6, guint _6_size); + uint32_t GetFriendListIds(IN int32_t _0, IN nn::account::Uid _1, IN nn::friends::detail::ipc::SizedFriendFilter _2, IN uint64_t _3, IN gpid _4, OUT int32_t& _5, OUT nn::account::NetworkServiceAccountId * _6, guint _6_size); + uint32_t GetFriendProfileImage(IN nn::account::Uid _0, IN nn::account::NetworkServiceAccountId _1, OUT int32_t& _2, OUT uint8_t * _3, guint _3_size); + uint32_t GetFriendRequestList(IN int32_t _0, IN int32_t _1, IN nn::account::Uid _2, OUT int32_t& _3, OUT nn::friends::detail::FriendRequestImpl * _4, guint _4_size); + uint32_t GetNewlyFriendCount(IN nn::account::Uid _0, OUT int32_t& _1); + uint32_t GetNintendoNetworkIdInfo(IN int32_t _0, IN nn::account::Uid _1, OUT int32_t& _2, OUT nn::friends::NintendoNetworkIdUserInfo * _3, guint _3_size, OUT nn::friends::detail::NintendoNetworkIdFriendImpl * _4, guint _4_size); + uint32_t GetPlayHistoryList(IN int32_t _0, IN nn::account::Uid _1, OUT int32_t& _2, OUT nn::friends::detail::PlayHistoryImpl * _3, guint _3_size); + uint32_t GetPlayHistoryRegistrationKey(IN bool _0, IN nn::account::Uid _1, OUT nn::friends::PlayHistoryRegistrationKey * _2, guint _2_size); + uint32_t GetPlayHistoryRegistrationKeyWithNetworkServiceAccountId(IN bool _0, IN nn::account::NetworkServiceAccountId _1, OUT nn::friends::PlayHistoryRegistrationKey * _2, guint _2_size); + uint32_t GetPlayHistoryStatistics(IN nn::account::Uid _0, OUT nn::friends::PlayHistoryStatistics& _1); + uint32_t GetProfileExtraFromFriendCode(IN nn::friends::FriendCode _0, IN nn::account::Uid _1, OUT nn::friends::detail::ProfileExtraImpl * _2, guint _2_size); + uint32_t GetProfileExtraList(IN nn::account::Uid _0, IN nn::account::NetworkServiceAccountId * _1, guint _1_size, OUT nn::friends::detail::ProfileExtraImpl * _2, guint _2_size); + uint32_t GetProfileImageUrl(IN nn::friends::Url _0, IN int32_t _1, OUT nn::friends::Url& _2); + uint32_t GetProfileList(IN nn::account::Uid _0, IN nn::account::NetworkServiceAccountId * _1, guint _1_size, OUT nn::friends::detail::ProfileImpl * _2, guint _2_size); + uint32_t GetReceivedFriendRequestCount(IN nn::account::Uid _0, OUT int32_t& _1, OUT int32_t& _2); + uint32_t GetRelationship(IN nn::account::Uid _0, IN nn::account::NetworkServiceAccountId _1, OUT nn::friends::Relationship& _2); + uint32_t GetUserPresenceView(IN nn::account::Uid _0, OUT nn::friends::detail::UserPresenceViewImpl * _1, guint _1_size); + uint32_t IssueFriendCode(IN nn::account::Uid _0); + uint32_t LoadFriendSetting(IN nn::account::Uid _0, IN nn::account::NetworkServiceAccountId _1, OUT nn::friends::detail::FriendSettingImpl * _2, guint _2_size); + uint32_t LoadUserSetting(IN nn::account::Uid _0, OUT nn::friends::detail::UserSettingImpl * _1, guint _1_size); + uint32_t ReadFriendRequest(IN nn::account::Uid _0, IN nn::friends::RequestId _1); + uint32_t RejectFriendRequest(IN nn::account::Uid _0, IN nn::friends::RequestId _1); + uint32_t RequestListSummaryOverlayNotification(); + uint32_t RequestSyncFriendList(IN nn::account::Uid _0); + uint32_t ResendFacedFriendRequest(IN nn::account::Uid _0, IN nn::account::NetworkServiceAccountId _1); + uint32_t SendFriendRequest(IN int32_t _0, IN nn::account::Uid _1, IN nn::account::NetworkServiceAccountId _2); + uint32_t SendFriendRequestForApplication(IN nn::account::Uid _0, IN nn::account::NetworkServiceAccountId _1, IN uint64_t _2, IN gpid _3, IN nn::friends::InAppScreenName * _4, guint _4_size, IN nn::friends::InAppScreenName * _5, guint _5_size); + uint32_t SendFriendRequestWithApplicationInfo(IN int32_t _0, IN nn::account::Uid _1, IN nn::account::NetworkServiceAccountId _2, IN nn::friends::ApplicationInfo _3, IN nn::friends::InAppScreenName * _4, guint _4_size, IN nn::friends::InAppScreenName * _5, guint _5_size); + uint32_t SendFriendRequestWithExternalApplicationCatalogId(IN int32_t _0, IN nn::account::Uid _1, IN nn::account::NetworkServiceAccountId _2, IN nn::friends::ExternalApplicationCatalogId _3, IN nn::friends::InAppScreenName * _4, guint _4_size, IN nn::friends::InAppScreenName * _5, guint _5_size); + uint32_t SendFriendRequestWithNintendoNetworkIdInfo(IN nn::friends::MiiName _0, IN nn::friends::MiiImageUrlParam _1, IN nn::friends::MiiName _2, IN nn::friends::MiiImageUrlParam _3, IN int32_t _4, IN nn::account::Uid _5, IN nn::account::NetworkServiceAccountId _6); + uint32_t SyncBlockedUserList(IN nn::account::Uid _0); + uint32_t SyncFriendList(IN nn::account::Uid _0); + uint32_t SyncUserSetting(IN nn::account::Uid _0); + uint32_t UnblockUser(IN nn::account::Uid _0, IN nn::account::NetworkServiceAccountId _1); + uint32_t UpdateFriendInfo(IN nn::account::Uid _0, IN uint64_t _1, IN gpid _2, IN nn::account::NetworkServiceAccountId * _3, guint _3_size, OUT nn::friends::detail::FriendImpl * _4, guint _4_size); + uint32_t UpdateUserPresence(IN nn::account::Uid _0, IN uint64_t _1, IN gpid _2, IN nn::friends::detail::UserPresenceImpl * _3, guint _3_size); + }; + class INotificationService { + public: + INotificationService(); + uint32_t Clear(); + uint32_t GetEvent(OUT KObject * _0); + uint32_t Pop(OUT nn::friends::detail::ipc::SizedNotificationInfo& _0); + }; + class IServiceCreator { + public: + IServiceCreator(); + uint32_t CreateFriendService(OUT nn::friends::detail::ipc::IFriendService * _0); + uint32_t CreateNotificationService(IN nn::account::Uid _0, OUT nn::friends::detail::ipc::INotificationService * _1); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::friends::detail::ipc::IFriendService::AcceptFriendRequest(IN nn::account::Uid _0, IN nn::friends::RequestId _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::AddFacedFriendRequest(IN nn::friends::FacedFriendRequestRegistrationKey _0, IN nn::account::Nickname _1, IN nn::account::Uid _2, IN uint8_t * _3, guint _3_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::AddFacedFriendRequestForApplication(IN nn::friends::FacedFriendRequestRegistrationKey _0, IN nn::account::Nickname _1, IN nn::account::Uid _2, IN uint64_t _3, IN gpid _4, IN uint8_t * _5, guint _5_size, IN nn::friends::InAppScreenName * _6, guint _6_size, IN nn::friends::InAppScreenName * _7, guint _7_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(0x19, 0, temp5); + ctu->cpu.readmem(temp4, temp6, temp5); + guint temp8; + auto temp7 = req.getBuffer(0x19, 1, temp8); + ctu->cpu.readmem(temp7, temp9, temp8); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + delete[] temp6; + delete[] temp9; + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::AddPlayHistory(IN nn::account::Uid _0, IN uint64_t _1, IN gpid _2, IN nn::friends::PlayHistoryRegistrationKey * _3, guint _3_size, IN nn::friends::InAppScreenName * _4, guint _4_size, IN nn::friends::InAppScreenName * _5, guint _5_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(0x19, 1, temp5); + ctu->cpu.readmem(temp4, temp6, temp5); + guint temp8; + auto temp7 = req.getBuffer(0x19, 2, temp8); + ctu->cpu.readmem(temp7, temp9, temp8); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + delete[] temp6; + delete[] temp9; + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::BlockUser(IN int32_t _0, IN nn::account::Uid _1, IN nn::account::NetworkServiceAccountId _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::BlockUserWithApplicationInfo(IN int32_t _0, IN nn::account::Uid _1, IN nn::account::NetworkServiceAccountId _2, IN nn::friends::ApplicationInfo _3, IN nn::friends::InAppScreenName * _4, guint _4_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::Cancel() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::CancelFacedFriendRequest(IN nn::account::Uid _0, IN nn::account::NetworkServiceAccountId _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::CancelFriendRequest(IN nn::account::Uid _0, IN nn::friends::RequestId _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::ChangeFriendFavoriteFlag(IN bool _0, IN nn::account::Uid _1, IN nn::account::NetworkServiceAccountId _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::ChangeFriendOnlineNotificationFlag(IN bool _0, IN nn::account::Uid _1, IN nn::account::NetworkServiceAccountId _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::ChangeFriendRequestReception(IN bool _0, IN nn::account::Uid _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::ChangePlayLogPermission(IN int32_t _0, IN nn::account::Uid _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::ChangePresencePermission(IN int32_t _0, IN nn::account::Uid _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::ClearPlayLog(IN nn::account::Uid _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::DeclareCloseOnlinePlaySession(IN nn::account::Uid _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::DeclareOpenOnlinePlaySession(IN nn::account::Uid _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::DeleteFriend(IN nn::account::Uid _0, IN nn::account::NetworkServiceAccountId _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::DeleteNetworkServiceAccountCache(IN nn::account::Uid _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::DeletePlayHistory(IN nn::account::Uid _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::DropFriendNewlyFlag(IN nn::account::Uid _0, IN nn::account::NetworkServiceAccountId _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::DropFriendNewlyFlags(IN nn::account::Uid _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::GetBlockedUserList(IN int32_t _0, IN nn::account::Uid _1, OUT int32_t& _2, OUT nn::friends::detail::BlockedUserImpl * _3, guint _3_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::GetBlockedUserListIds(IN int32_t _0, IN nn::account::Uid _1, OUT int32_t& _2, OUT nn::account::NetworkServiceAccountId * _3, guint _3_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0xa, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::GetCompletionEvent(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::GetExternalApplicationCatalog(IN nn::settings::LanguageCode _0, IN nn::friends::ExternalApplicationCatalogId _1, OUT nn::friends::ExternalApplicationCatalog * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::GetFacedFriendRequestProfileImage(IN nn::account::Uid _0, IN nn::account::NetworkServiceAccountId _1, OUT int32_t& _2, OUT uint8_t * _3, guint _3_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::GetFacedFriendRequestProfileImageFromPath(IN int8_t * _0, guint _0_size, OUT int32_t& _1, OUT uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(9, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(6, 0, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::GetFacedFriendRequestRegistrationKey(IN nn::account::Uid _0, OUT nn::friends::FacedFriendRequestRegistrationKey& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::GetFriendCandidateList(IN int32_t _0, IN nn::account::Uid _1, OUT int32_t& _2, OUT nn::friends::detail::FriendCandidateImpl * _3, guint _3_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::GetFriendCount(IN nn::account::Uid _0, IN nn::friends::detail::ipc::SizedFriendFilter _1, IN uint64_t _2, IN gpid _3, OUT int32_t& _4) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::GetFriendDetailedInfo(IN nn::account::Uid _0, IN nn::account::NetworkServiceAccountId _1, OUT nn::friends::detail::FriendDetailedInfoImpl * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::GetFriendList(IN int32_t _0, IN nn::account::Uid _1, IN nn::friends::detail::ipc::SizedFriendFilter _2, IN uint64_t _3, IN gpid _4, OUT int32_t& _5, OUT nn::friends::detail::FriendImpl * _6, guint _6_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::GetFriendListIds(IN int32_t _0, IN nn::account::Uid _1, IN nn::friends::detail::ipc::SizedFriendFilter _2, IN uint64_t _3, IN gpid _4, OUT int32_t& _5, OUT nn::account::NetworkServiceAccountId * _6, guint _6_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0xa, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::GetFriendProfileImage(IN nn::account::Uid _0, IN nn::account::NetworkServiceAccountId _1, OUT int32_t& _2, OUT uint8_t * _3, guint _3_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::GetFriendRequestList(IN int32_t _0, IN int32_t _1, IN nn::account::Uid _2, OUT int32_t& _3, OUT nn::friends::detail::FriendRequestImpl * _4, guint _4_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::GetNewlyFriendCount(IN nn::account::Uid _0, OUT int32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::GetNintendoNetworkIdInfo(IN int32_t _0, IN nn::account::Uid _1, OUT int32_t& _2, OUT nn::friends::NintendoNetworkIdUserInfo * _3, guint _3_size, OUT nn::friends::detail::NintendoNetworkIdFriendImpl * _4, guint _4_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + guint temp5; + auto temp4 = req.getBuffer(6, 0, temp5); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::GetPlayHistoryList(IN int32_t _0, IN nn::account::Uid _1, OUT int32_t& _2, OUT nn::friends::detail::PlayHistoryImpl * _3, guint _3_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::GetPlayHistoryRegistrationKey(IN bool _0, IN nn::account::Uid _1, OUT nn::friends::PlayHistoryRegistrationKey * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::GetPlayHistoryRegistrationKeyWithNetworkServiceAccountId(IN bool _0, IN nn::account::NetworkServiceAccountId _1, OUT nn::friends::PlayHistoryRegistrationKey * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::GetPlayHistoryStatistics(IN nn::account::Uid _0, OUT nn::friends::PlayHistoryStatistics& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::GetProfileExtraFromFriendCode(IN nn::friends::FriendCode _0, IN nn::account::Uid _1, OUT nn::friends::detail::ProfileExtraImpl * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::GetProfileExtraList(IN nn::account::Uid _0, IN nn::account::NetworkServiceAccountId * _1, guint _1_size, OUT nn::friends::detail::ProfileExtraImpl * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(9, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(6, 0, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::GetProfileImageUrl(IN nn::friends::Url _0, IN int32_t _1, OUT nn::friends::Url& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::GetProfileList(IN nn::account::Uid _0, IN nn::account::NetworkServiceAccountId * _1, guint _1_size, OUT nn::friends::detail::ProfileImpl * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(9, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(6, 0, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::GetReceivedFriendRequestCount(IN nn::account::Uid _0, OUT int32_t& _1, OUT int32_t& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::GetRelationship(IN nn::account::Uid _0, IN nn::account::NetworkServiceAccountId _1, OUT nn::friends::Relationship& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::GetUserPresenceView(IN nn::account::Uid _0, OUT nn::friends::detail::UserPresenceViewImpl * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::IssueFriendCode(IN nn::account::Uid _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::LoadFriendSetting(IN nn::account::Uid _0, IN nn::account::NetworkServiceAccountId _1, OUT nn::friends::detail::FriendSettingImpl * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::LoadUserSetting(IN nn::account::Uid _0, OUT nn::friends::detail::UserSettingImpl * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::ReadFriendRequest(IN nn::account::Uid _0, IN nn::friends::RequestId _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::RejectFriendRequest(IN nn::account::Uid _0, IN nn::friends::RequestId _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::RequestListSummaryOverlayNotification() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::RequestSyncFriendList(IN nn::account::Uid _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::ResendFacedFriendRequest(IN nn::account::Uid _0, IN nn::account::NetworkServiceAccountId _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::SendFriendRequest(IN int32_t _0, IN nn::account::Uid _1, IN nn::account::NetworkServiceAccountId _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::SendFriendRequestForApplication(IN nn::account::Uid _0, IN nn::account::NetworkServiceAccountId _1, IN uint64_t _2, IN gpid _3, IN nn::friends::InAppScreenName * _4, guint _4_size, IN nn::friends::InAppScreenName * _5, guint _5_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(0x19, 1, temp5); + ctu->cpu.readmem(temp4, temp6, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + delete[] temp6; + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::SendFriendRequestWithApplicationInfo(IN int32_t _0, IN nn::account::Uid _1, IN nn::account::NetworkServiceAccountId _2, IN nn::friends::ApplicationInfo _3, IN nn::friends::InAppScreenName * _4, guint _4_size, IN nn::friends::InAppScreenName * _5, guint _5_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(0x19, 1, temp5); + ctu->cpu.readmem(temp4, temp6, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + delete[] temp6; + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::SendFriendRequestWithExternalApplicationCatalogId(IN int32_t _0, IN nn::account::Uid _1, IN nn::account::NetworkServiceAccountId _2, IN nn::friends::ExternalApplicationCatalogId _3, IN nn::friends::InAppScreenName * _4, guint _4_size, IN nn::friends::InAppScreenName * _5, guint _5_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(0x19, 1, temp5); + ctu->cpu.readmem(temp4, temp6, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + delete[] temp6; + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::SendFriendRequestWithNintendoNetworkIdInfo(IN nn::friends::MiiName _0, IN nn::friends::MiiImageUrlParam _1, IN nn::friends::MiiName _2, IN nn::friends::MiiImageUrlParam _3, IN int32_t _4, IN nn::account::Uid _5, IN nn::account::NetworkServiceAccountId _6) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::SyncBlockedUserList(IN nn::account::Uid _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::SyncFriendList(IN nn::account::Uid _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::SyncUserSetting(IN nn::account::Uid _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::UnblockUser(IN nn::account::Uid _0, IN nn::account::NetworkServiceAccountId _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::UpdateFriendInfo(IN nn::account::Uid _0, IN uint64_t _1, IN gpid _2, IN nn::account::NetworkServiceAccountId * _3, guint _3_size, OUT nn::friends::detail::FriendImpl * _4, guint _4_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(9, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(6, 0, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +uint32_t nn::friends::detail::ipc::IFriendService::UpdateUserPresence(IN nn::account::Uid _0, IN uint64_t _1, IN gpid _2, IN nn::friends::detail::UserPresenceImpl * _3, guint _3_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::friends::detail::ipc::INotificationService::Clear() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::friends::detail::ipc::INotificationService::GetEvent(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::friends::detail::ipc::INotificationService::Pop(OUT nn::friends::detail::ipc::SizedNotificationInfo& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::friends::detail::ipc::IServiceCreator::CreateFriendService(OUT nn::friends::detail::ipc::IFriendService * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::friends::detail::ipc::IFriendService(resp.move_handles[0]); + return ret; +} +uint32_t nn::friends::detail::ipc::IServiceCreator::CreateNotificationService(IN nn::account::Uid _0, OUT nn::friends::detail::ipc::INotificationService * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new nn::friends::detail::ipc::INotificationService(resp.move_handles[0]); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::fssrv::sf { + class IDeviceOperator { + public: + IDeviceOperator(); + uint32_t EraseAndWriteParamDirectly(IN uint64_t _0, IN uint8_t * _1, guint _1_size); + uint32_t EraseGameCard(IN uint32_t _0, IN uint64_t _1); + uint32_t EraseMmc(IN uint32_t _0); + uint32_t FinalizeGameCardDriver(); + uint32_t ForceEraseGameCard(); + uint32_t GetAndClearMmcErrorInfo(IN uint64_t _0, OUT uint128_t& _1, OUT uint64_t& _2, OUT uint8_t * _3, guint _3_size); + uint32_t GetAndClearSdCardErrorInfo(IN uint64_t _0, OUT uint128_t& _1, OUT uint64_t& _2, OUT uint8_t * _3, guint _3_size); + uint32_t GetGameCardAsicInfo(IN uint64_t _0, IN uint64_t _1, IN uint8_t * _2, guint _2_size, OUT uint8_t * _3, guint _3_size); + uint32_t GetGameCardAttribute(IN uint32_t _0, OUT uint8_t& attribute); + uint32_t GetGameCardCid(IN uint64_t _0, OUT uint8_t * cid, guint cid_size); + uint32_t GetGameCardDeviceCertificate(IN uint64_t _0, IN uint32_t _1, OUT uint8_t * certificate, guint certificate_size); + uint32_t GetGameCardDeviceId(IN uint64_t _0, OUT uint8_t * deviceID, guint deviceID_size); + uint32_t GetGameCardDeviceIdForProdCard(IN uint64_t _0, IN uint64_t _1, IN uint8_t * _2, guint _2_size, OUT uint8_t * errorInfo, guint errorInfo_size); + uint32_t GetGameCardErrorInfo(OUT uint128_t& errorInfo); + uint32_t GetGameCardErrorReportInfo(OUT uint8_t * errorReportInfo); + uint32_t GetGameCardHandle(OUT uint32_t& gamecardHandle); + uint32_t GetGameCardIdSet(IN uint64_t _0, OUT uint8_t * _1, guint _1_size); + uint32_t GetGameCardImageHash(IN uint64_t _0, IN uint32_t _1, OUT uint8_t * imageHash, guint imageHash_size); + uint32_t GetGameCardUpdatePartitionInfo(IN uint32_t _0, OUT uint32_t& version, OUT nn::ApplicationId& TID); + uint32_t GetMmcCid(IN uint64_t _0, OUT uint8_t * cid, guint cid_size); + uint32_t GetMmcExtendedCsd(IN uint64_t _0, OUT uint8_t * _1, guint _1_size); + uint32_t GetMmcPartitionSize(IN uint32_t _0, OUT uint64_t& paritionSize); + uint32_t GetMmcPatrolCount(OUT uint32_t& patrolCount); + uint32_t GetMmcSpeedMode(OUT uint64_t& speedMode); + uint32_t GetSdCardCid(IN uint64_t _0, OUT uint8_t * cid, guint cid_size); + uint32_t GetSdCardProtectedAreaSize(OUT uint64_t& protectedSize); + uint32_t GetSdCardSpeedMode(OUT uint64_t& sdSpeed); + uint32_t GetSdCardUserAreaSize(OUT uint64_t& size); + uint32_t GetSpeedEmulationMode(OUT uint32_t& emuMode); + uint32_t IsGameCardInserted(OUT uint8_t& isGameInserted); + uint32_t IsSdCardInserted(OUT uint8_t& isSdInserted); + uint32_t SetSpeedEmulationMode(IN uint32_t mode); + uint32_t SetVerifyWriteEnalbleFlag(IN uint8_t flag); + uint32_t WriteToGameCard(IN uint64_t _0, IN uint64_t _1, OUT uint8_t * _2, guint _2_size); + }; + class IDirectory { + public: + IDirectory(); + uint32_t GetEntryCount(OUT uint64_t& _0); + uint32_t Read(OUT uint64_t& _0, OUT uint8_t * _1, guint _1_size); + }; + class IEventNotifier { + public: + IEventNotifier(); + uint32_t Unknown0(OUT KObject * _0); + }; + class IFile { + public: + IFile(); + uint32_t Flush(); + uint32_t GetSize(OUT uint64_t& fileSize); + uint32_t Read(IN uint64_t _0, IN uint64_t offset, IN uint32_t size, OUT uint64_t& out_size, OUT int8_t * out_buf, guint out_buf_size); + uint32_t SetSize(IN uint64_t size); + uint32_t Write(IN uint64_t _0, IN uint64_t offset, IN uint32_t size, IN int8_t * buf, guint buf_size); + }; + class IFileSystem { + public: + IFileSystem(); + uint32_t CleanDirectoryRecursively(IN int8_t * path, guint path_size); + uint32_t Commit(); + uint32_t CreateDirectory(IN int8_t * path, guint path_size); + uint32_t CreateFile(IN uint64_t mode, IN uint32_t size, IN int8_t * path, guint path_size); + uint32_t DeleteDirectory(IN int8_t * path, guint path_size); + uint32_t DeleteDirectoryRecursively(IN int8_t * path, guint path_size); + uint32_t DeleteFile(IN int8_t * path, guint path_size); + uint32_t GetEntryType(IN int8_t * path, guint path_size, OUT uint32_t& _1); + uint32_t GetFileTimeStampRaw(IN int8_t * path, guint path_size, OUT uint8_t * timestamp); + uint32_t GetFreeSpaceSize(IN int8_t * path, guint path_size, OUT uint64_t& totalFreeSpace); + uint32_t GetTotalSpaceSize(IN int8_t * path, guint path_size, OUT uint64_t& totalSize); + uint32_t OpenDirectory(IN uint32_t _0, IN int8_t * path, guint path_size, OUT nn::fssrv::sf::IDirectory * directory); + uint32_t OpenFile(IN uint32_t mode, IN int8_t * path, guint path_size, OUT nn::fssrv::sf::IFile * file); + uint32_t RenameDirectory(IN int8_t * oldPath, guint oldPath_size, IN int8_t * newPath, guint newPath_size); + uint32_t RenameFile(IN int8_t * oldPath, guint oldPath_size, IN int8_t * newPath, guint newPath_size); + }; + class IFileSystemProxy { + public: + IFileSystemProxy(); + uint32_t CorruptSaveDataForDebug(IN nn::ApplicationId tid); + uint32_t CreatePaddingFile(IN uint64_t size); + uint32_t CreateSaveData(IN nn::fssrv::sf::SaveStruct saveStruct, IN nn::fssrv::sf::SaveCreateStruct saveCreate, IN uint128_t input); + uint32_t CreateSystemSaveData(IN nn::fssrv::sf::SaveStruct saveStruct, IN nn::fssrv::sf::SaveCreateStruct saveCreate); + uint32_t DeleteAllPaddingFiles(); + uint32_t DeleteSaveData(IN nn::ApplicationId tid); + uint32_t DeleteSaveDataWithSpaceId(IN uint8_t _0, IN uint64_t _1); + uint32_t DisableAutoSaveDataCreation(); + uint32_t ExtendSaveData(IN uint8_t _0, IN uint64_t _1, IN uint64_t _2, IN uint64_t _3); + uint32_t FormatSdCard(); + uint32_t FormatSdCardDryRun(); + uint32_t GetAndClearFileSystemProxyErrorInfo(OUT uint8_t * errorInfo); + uint32_t GetGlobalAccessLogMode(OUT uint32_t& logMode); + uint32_t GetRightsId(IN uint64_t _0, IN uint8_t _1, OUT uint128_t& rights); + uint32_t GetRightsIdByPath(IN int8_t * path, guint path_size, OUT uint128_t& rights); + uint32_t GetRightsIdByPath2(IN int8_t * path, guint path_size, OUT uint128_t& rights, OUT uint8_t& _2); + uint32_t Initialize(IN uint64_t _0, IN gpid _1); + uint32_t InvalidateBisCache(); + uint32_t IsExFatSupported(OUT uint8_t& isSupported); + uint32_t MountBis(IN nn::fssrv::sf::Partition partitionID, IN int8_t * path, guint path_size, OUT nn::fssrv::sf::IFileSystem * Bis); + uint32_t MountContent(IN nn::ApplicationId tid, IN uint32_t flag, IN int8_t * path, guint path_size, OUT nn::fssrv::sf::IFileSystem * contentFs); + uint32_t MountContent7(IN nn::ApplicationId tid, IN uint32_t ncaType, OUT nn::fssrv::sf::IFileSystem * _2); + uint32_t MountContentStorage(IN uint32_t contentStorageID, OUT nn::fssrv::sf::IFileSystem * contentFs); + uint32_t MountGameCardPartition(IN uint32_t _0, IN uint32_t _1, OUT nn::fssrv::sf::IFileSystem * gameCardPartitionFs); + uint32_t MountImageDirectory(IN uint32_t _0, OUT nn::fssrv::sf::IFileSystem * imageFs); + uint32_t MountSaveData(IN uint8_t input, IN nn::fssrv::sf::SaveStruct saveStruct, OUT nn::fssrv::sf::IFileSystem * saveDataFs); + uint32_t MountSaveDataReadOnly(IN uint8_t input, IN nn::fssrv::sf::SaveStruct saveStruct, OUT nn::fssrv::sf::IFileSystem * saveDataFs); + uint32_t MountSdCard(OUT nn::fssrv::sf::IFileSystem * sdCard); + uint32_t MountSystemSaveData(IN uint8_t input, IN nn::fssrv::sf::SaveStruct saveStruct, OUT nn::fssrv::sf::IFileSystem * systemSaveDataFs); + uint32_t OpenBisPartition(IN nn::fssrv::sf::Partition partitionID, OUT nn::fssrv::sf::IStorage * BisPartition); + uint32_t OpenDataFileSystemByApplicationId(IN nn::ApplicationId tid, OUT nn::fssrv::sf::IFileSystem * dataFiles); + uint32_t OpenDataFileSystemByCurrentProcess(OUT nn::fssrv::sf::IFileSystem * _0); + uint32_t OpenDataStorageByApplicationId(IN nn::ApplicationId tid, OUT nn::fssrv::sf::IStorage * dataStorage); + uint32_t OpenDataStorageByCurrentProcess(OUT nn::fssrv::sf::IStorage * dataStorage); + uint32_t OpenDataStorageByDataId(IN nn::ApplicationId tid, IN uint8_t storageId, OUT nn::fssrv::sf::IStorage * dataStorage); + uint32_t OpenDeviceOperator(OUT nn::fssrv::sf::IDeviceOperator * _0); + uint32_t OpenGameCardDetectionEventNotifier(OUT nn::fssrv::sf::IEventNotifier * GameCardEventNotify); + uint32_t OpenGameCardPartition(IN nn::fssrv::sf::Partition partitionID, IN uint32_t _1, OUT nn::fssrv::sf::IStorage * gameCardFs); + uint32_t OpenHostFileSystemImpl(IN int8_t * path, guint path_size, OUT nn::fssrv::sf::IFileSystem * _1); + uint32_t OpenRomStorage(OUT nn::fssrv::sf::IStorage * _0); + uint32_t OpenSaveDataInfoReader(OUT nn::fssrv::sf::ISaveDataInfoReader * _0); + uint32_t OpenSaveDataIterator(IN uint8_t _0, OUT IUnknown * _1); + uint32_t OpenSaveDataThumbnailFile(IN uint8_t _0, IN uint8_t * _1, IN uint32_t _2, OUT nn::fssrv::sf::IFile * thumbnail); + uint32_t OpenSdCardDetectionEventNotifier(OUT nn::fssrv::sf::IEventNotifier * SdEventNotify); + uint32_t OutputAccessLogToSdCard(IN void * logText, guint logText_size); + uint32_t QuerySaveDataTotalSize(IN uint64_t _0, IN uint64_t _1, OUT uint64_t& saveDataSize); + uint32_t ReadSaveDataFileSystemExtraData(IN uint64_t _0, OUT void * _1, guint _1_size); + uint32_t ReadSaveDataFileSystemExtraDataWithSpaceId(IN uint8_t _0, IN uint64_t _1, OUT void * _2, guint _2_size); + uint32_t RegisterExternalKey(IN uint128_t _0, IN uint128_t _1); + uint32_t RegisterSaveDataAtomicDeletion(IN void * _0, guint _0_size); + uint32_t SetBisRootForHost(IN uint32_t _0, IN int8_t * path, guint path_size); + uint32_t SetCurrentPosixTime(IN uint64_t time); + uint32_t SetGlobalAccessLogMode(IN uint32_t mode); + uint32_t SetSaveDataRootPath(IN int8_t * path, guint path_size); + uint32_t SetSaveDataSize(IN uint64_t _0, IN uint64_t _1); + uint32_t SetSdCardEncryptionSeed(IN uint128_t seedmaybe); + uint32_t UnregisterExternalKey(); + uint32_t VerifySaveData(IN nn::ApplicationId tid, OUT void * _1, guint _1_size); + uint32_t WriteSaveDataFileSystemExtraData(IN uint64_t _0, IN uint8_t _1, IN void * _2, guint _2_size); + }; + class IFileSystemProxyForLoader { + public: + IFileSystemProxyForLoader(); + uint32_t IsCodeMounted(IN nn::ApplicationId TID, OUT uint8_t& isMounted); + uint32_t MountCode(IN nn::ApplicationId TID, IN int8_t * contentPath, guint contentPath_size, OUT nn::fssrv::sf::IFileSystem * contentFs); + }; + class IProgramRegistry { + public: + IProgramRegistry(); + uint32_t ClearFsPermissions(IN uint64_t pid); + uint32_t SetEnabledProgramVerification(IN uint8_t enabled); + uint32_t SetFsPermissions(IN uint64_t _0, IN uint64_t _1, IN uint8_t _2, IN uint64_t _3, IN uint64_t _4, IN uint8_t * _5, guint _5_size, IN uint8_t * _6, guint _6_size); + }; + class ISaveDataInfoReader { + public: + ISaveDataInfoReader(); + uint32_t Unknown0(OUT uint64_t& _0, OUT uint8_t * _1, guint _1_size); + }; + class IStorage { + public: + IStorage(); + uint32_t Flush(); + uint32_t GetSize(OUT uint64_t& size); + uint32_t Read(IN uint64_t offset, IN uint64_t length, OUT int8_t * buffer, guint buffer_size); + uint32_t SetSize(IN uint64_t size); + uint32_t Write(IN uint64_t offset, IN uint64_t length, IN int8_t * data, guint data_size); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::fssrv::sf::IDeviceOperator::EraseAndWriteParamDirectly(IN uint64_t _0, IN uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::fssrv::sf::IDeviceOperator::EraseGameCard(IN uint32_t _0, IN uint64_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IDeviceOperator::EraseMmc(IN uint32_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IDeviceOperator::FinalizeGameCardDriver() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IDeviceOperator::ForceEraseGameCard() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IDeviceOperator::GetAndClearMmcErrorInfo(IN uint64_t _0, OUT uint128_t& _1, OUT uint64_t& _2, OUT uint8_t * _3, guint _3_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::fssrv::sf::IDeviceOperator::GetAndClearSdCardErrorInfo(IN uint64_t _0, OUT uint128_t& _1, OUT uint64_t& _2, OUT uint8_t * _3, guint _3_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::fssrv::sf::IDeviceOperator::GetGameCardAsicInfo(IN uint64_t _0, IN uint64_t _1, IN uint8_t * _2, guint _2_size, OUT uint8_t * _3, guint _3_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(6, 0, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +uint32_t nn::fssrv::sf::IDeviceOperator::GetGameCardAttribute(IN uint32_t _0, OUT uint8_t& attribute) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IDeviceOperator::GetGameCardCid(IN uint64_t _0, OUT uint8_t * cid, guint cid_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::fssrv::sf::IDeviceOperator::GetGameCardDeviceCertificate(IN uint64_t _0, IN uint32_t _1, OUT uint8_t * certificate, guint certificate_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::fssrv::sf::IDeviceOperator::GetGameCardDeviceId(IN uint64_t _0, OUT uint8_t * deviceID, guint deviceID_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::fssrv::sf::IDeviceOperator::GetGameCardDeviceIdForProdCard(IN uint64_t _0, IN uint64_t _1, IN uint8_t * _2, guint _2_size, OUT uint8_t * errorInfo, guint errorInfo_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(6, 0, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +uint32_t nn::fssrv::sf::IDeviceOperator::GetGameCardErrorInfo(OUT uint128_t& errorInfo) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IDeviceOperator::GetGameCardErrorReportInfo(OUT uint8_t * errorReportInfo) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IDeviceOperator::GetGameCardHandle(OUT uint32_t& gamecardHandle) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IDeviceOperator::GetGameCardIdSet(IN uint64_t _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::fssrv::sf::IDeviceOperator::GetGameCardImageHash(IN uint64_t _0, IN uint32_t _1, OUT uint8_t * imageHash, guint imageHash_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::fssrv::sf::IDeviceOperator::GetGameCardUpdatePartitionInfo(IN uint32_t _0, OUT uint32_t& version, OUT nn::ApplicationId& TID) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IDeviceOperator::GetMmcCid(IN uint64_t _0, OUT uint8_t * cid, guint cid_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::fssrv::sf::IDeviceOperator::GetMmcExtendedCsd(IN uint64_t _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::fssrv::sf::IDeviceOperator::GetMmcPartitionSize(IN uint32_t _0, OUT uint64_t& paritionSize) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IDeviceOperator::GetMmcPatrolCount(OUT uint32_t& patrolCount) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IDeviceOperator::GetMmcSpeedMode(OUT uint64_t& speedMode) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IDeviceOperator::GetSdCardCid(IN uint64_t _0, OUT uint8_t * cid, guint cid_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::fssrv::sf::IDeviceOperator::GetSdCardProtectedAreaSize(OUT uint64_t& protectedSize) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IDeviceOperator::GetSdCardSpeedMode(OUT uint64_t& sdSpeed) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IDeviceOperator::GetSdCardUserAreaSize(OUT uint64_t& size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IDeviceOperator::GetSpeedEmulationMode(OUT uint32_t& emuMode) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IDeviceOperator::IsGameCardInserted(OUT uint8_t& isGameInserted) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IDeviceOperator::IsSdCardInserted(OUT uint8_t& isSdInserted) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IDeviceOperator::SetSpeedEmulationMode(IN uint32_t mode) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IDeviceOperator::SetVerifyWriteEnalbleFlag(IN uint8_t flag) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IDeviceOperator::WriteToGameCard(IN uint64_t _0, IN uint64_t _1, OUT uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::fssrv::sf::IDirectory::GetEntryCount(OUT uint64_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IDirectory::Read(OUT uint64_t& _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::fssrv::sf::IEventNotifier::Unknown0(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::fssrv::sf::IFile::Flush() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IFile::GetSize(OUT uint64_t& fileSize) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IFile::Read(IN uint64_t _0, IN uint64_t offset, IN uint32_t size, OUT uint64_t& out_size, OUT int8_t * out_buf, guint out_buf_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x46, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::fssrv::sf::IFile::SetSize(IN uint64_t size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IFile::Write(IN uint64_t _0, IN uint64_t offset, IN uint32_t size, IN int8_t * buf, guint buf_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x45, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::fssrv::sf::IFileSystem::CleanDirectoryRecursively(IN int8_t * path, guint path_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::fssrv::sf::IFileSystem::Commit() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystem::CreateDirectory(IN int8_t * path, guint path_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::fssrv::sf::IFileSystem::CreateFile(IN uint64_t mode, IN uint32_t size, IN int8_t * path, guint path_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::fssrv::sf::IFileSystem::DeleteDirectory(IN int8_t * path, guint path_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::fssrv::sf::IFileSystem::DeleteDirectoryRecursively(IN int8_t * path, guint path_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::fssrv::sf::IFileSystem::DeleteFile(IN int8_t * path, guint path_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::fssrv::sf::IFileSystem::GetEntryType(IN int8_t * path, guint path_size, OUT uint32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::fssrv::sf::IFileSystem::GetFileTimeStampRaw(IN int8_t * path, guint path_size, OUT uint8_t * timestamp) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto temp4 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::fssrv::sf::IFileSystem::GetFreeSpaceSize(IN int8_t * path, guint path_size, OUT uint64_t& totalFreeSpace) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::fssrv::sf::IFileSystem::GetTotalSpaceSize(IN int8_t * path, guint path_size, OUT uint64_t& totalSize) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::fssrv::sf::IFileSystem::OpenDirectory(IN uint32_t _0, IN int8_t * path, guint path_size, OUT nn::fssrv::sf::IDirectory * directory) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + directory OMG = new nn::fssrv::sf::IDirectory(resp.move_handles[0]); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystem::OpenFile(IN uint32_t mode, IN int8_t * path, guint path_size, OUT nn::fssrv::sf::IFile * file) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + file OMG = new nn::fssrv::sf::IFile(resp.move_handles[0]); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystem::RenameDirectory(IN int8_t * oldPath, guint oldPath_size, IN int8_t * newPath, guint newPath_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(0x19, 1, temp5); + ctu->cpu.readmem(temp4, temp6, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + delete[] temp6; + return ret; +} +uint32_t nn::fssrv::sf::IFileSystem::RenameFile(IN int8_t * oldPath, guint oldPath_size, IN int8_t * newPath, guint newPath_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(0x19, 1, temp5); + ctu->cpu.readmem(temp4, temp6, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + delete[] temp6; + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::CorruptSaveDataForDebug(IN nn::ApplicationId tid) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::CreatePaddingFile(IN uint64_t size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::CreateSaveData(IN nn::fssrv::sf::SaveStruct saveStruct, IN nn::fssrv::sf::SaveCreateStruct saveCreate, IN uint128_t input) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::CreateSystemSaveData(IN nn::fssrv::sf::SaveStruct saveStruct, IN nn::fssrv::sf::SaveCreateStruct saveCreate) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::DeleteAllPaddingFiles() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::DeleteSaveData(IN nn::ApplicationId tid) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::DeleteSaveDataWithSpaceId(IN uint8_t _0, IN uint64_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::DisableAutoSaveDataCreation() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::ExtendSaveData(IN uint8_t _0, IN uint64_t _1, IN uint64_t _2, IN uint64_t _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::FormatSdCard() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::FormatSdCardDryRun() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::GetAndClearFileSystemProxyErrorInfo(OUT uint8_t * errorInfo) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::GetGlobalAccessLogMode(OUT uint32_t& logMode) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::GetRightsId(IN uint64_t _0, IN uint8_t _1, OUT uint128_t& rights) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::GetRightsIdByPath(IN int8_t * path, guint path_size, OUT uint128_t& rights) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::GetRightsIdByPath2(IN int8_t * path, guint path_size, OUT uint128_t& rights, OUT uint8_t& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::Initialize(IN uint64_t _0, IN gpid _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::InvalidateBisCache() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::IsExFatSupported(OUT uint8_t& isSupported) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::MountBis(IN nn::fssrv::sf::Partition partitionID, IN int8_t * path, guint path_size, OUT nn::fssrv::sf::IFileSystem * Bis) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + Bis OMG = new nn::fssrv::sf::IFileSystem(resp.move_handles[0]); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::MountContent(IN nn::ApplicationId tid, IN uint32_t flag, IN int8_t * path, guint path_size, OUT nn::fssrv::sf::IFileSystem * contentFs) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + contentFs OMG = new nn::fssrv::sf::IFileSystem(resp.move_handles[0]); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::MountContent7(IN nn::ApplicationId tid, IN uint32_t ncaType, OUT nn::fssrv::sf::IFileSystem * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _2 OMG = new nn::fssrv::sf::IFileSystem(resp.move_handles[0]); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::MountContentStorage(IN uint32_t contentStorageID, OUT nn::fssrv::sf::IFileSystem * contentFs) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + contentFs OMG = new nn::fssrv::sf::IFileSystem(resp.move_handles[0]); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::MountGameCardPartition(IN uint32_t _0, IN uint32_t _1, OUT nn::fssrv::sf::IFileSystem * gameCardPartitionFs) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + gameCardPartitionFs OMG = new nn::fssrv::sf::IFileSystem(resp.move_handles[0]); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::MountImageDirectory(IN uint32_t _0, OUT nn::fssrv::sf::IFileSystem * imageFs) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + imageFs OMG = new nn::fssrv::sf::IFileSystem(resp.move_handles[0]); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::MountSaveData(IN uint8_t input, IN nn::fssrv::sf::SaveStruct saveStruct, OUT nn::fssrv::sf::IFileSystem * saveDataFs) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + saveDataFs OMG = new nn::fssrv::sf::IFileSystem(resp.move_handles[0]); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::MountSaveDataReadOnly(IN uint8_t input, IN nn::fssrv::sf::SaveStruct saveStruct, OUT nn::fssrv::sf::IFileSystem * saveDataFs) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + saveDataFs OMG = new nn::fssrv::sf::IFileSystem(resp.move_handles[0]); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::MountSdCard(OUT nn::fssrv::sf::IFileSystem * sdCard) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + sdCard OMG = new nn::fssrv::sf::IFileSystem(resp.move_handles[0]); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::MountSystemSaveData(IN uint8_t input, IN nn::fssrv::sf::SaveStruct saveStruct, OUT nn::fssrv::sf::IFileSystem * systemSaveDataFs) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + systemSaveDataFs OMG = new nn::fssrv::sf::IFileSystem(resp.move_handles[0]); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::OpenBisPartition(IN nn::fssrv::sf::Partition partitionID, OUT nn::fssrv::sf::IStorage * BisPartition) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + BisPartition OMG = new nn::fssrv::sf::IStorage(resp.move_handles[0]); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::OpenDataFileSystemByApplicationId(IN nn::ApplicationId tid, OUT nn::fssrv::sf::IFileSystem * dataFiles) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + dataFiles OMG = new nn::fssrv::sf::IFileSystem(resp.move_handles[0]); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::OpenDataFileSystemByCurrentProcess(OUT nn::fssrv::sf::IFileSystem * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::fssrv::sf::IFileSystem(resp.move_handles[0]); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::OpenDataStorageByApplicationId(IN nn::ApplicationId tid, OUT nn::fssrv::sf::IStorage * dataStorage) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + dataStorage OMG = new nn::fssrv::sf::IStorage(resp.move_handles[0]); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::OpenDataStorageByCurrentProcess(OUT nn::fssrv::sf::IStorage * dataStorage) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + dataStorage OMG = new nn::fssrv::sf::IStorage(resp.move_handles[0]); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::OpenDataStorageByDataId(IN nn::ApplicationId tid, IN uint8_t storageId, OUT nn::fssrv::sf::IStorage * dataStorage) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + dataStorage OMG = new nn::fssrv::sf::IStorage(resp.move_handles[0]); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::OpenDeviceOperator(OUT nn::fssrv::sf::IDeviceOperator * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::fssrv::sf::IDeviceOperator(resp.move_handles[0]); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::OpenGameCardDetectionEventNotifier(OUT nn::fssrv::sf::IEventNotifier * GameCardEventNotify) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + GameCardEventNotify OMG = new nn::fssrv::sf::IEventNotifier(resp.move_handles[0]); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::OpenGameCardPartition(IN nn::fssrv::sf::Partition partitionID, IN uint32_t _1, OUT nn::fssrv::sf::IStorage * gameCardFs) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + gameCardFs OMG = new nn::fssrv::sf::IStorage(resp.move_handles[0]); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::OpenHostFileSystemImpl(IN int8_t * path, guint path_size, OUT nn::fssrv::sf::IFileSystem * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + _1 OMG = new nn::fssrv::sf::IFileSystem(resp.move_handles[0]); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::OpenRomStorage(OUT nn::fssrv::sf::IStorage * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::fssrv::sf::IStorage(resp.move_handles[0]); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::OpenSaveDataInfoReader(OUT nn::fssrv::sf::ISaveDataInfoReader * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::fssrv::sf::ISaveDataInfoReader(resp.move_handles[0]); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::OpenSaveDataIterator(IN uint8_t _0, OUT IUnknown * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new IUnknown(resp.move_handles[0]); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::OpenSaveDataThumbnailFile(IN uint8_t _0, IN uint8_t * _1, IN uint32_t _2, OUT nn::fssrv::sf::IFile * thumbnail) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + thumbnail OMG = new nn::fssrv::sf::IFile(resp.move_handles[0]); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::OpenSdCardDetectionEventNotifier(OUT nn::fssrv::sf::IEventNotifier * SdEventNotify) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + SdEventNotify OMG = new nn::fssrv::sf::IEventNotifier(resp.move_handles[0]); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::OutputAccessLogToSdCard(IN void * logText, guint logText_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::QuerySaveDataTotalSize(IN uint64_t _0, IN uint64_t _1, OUT uint64_t& saveDataSize) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::ReadSaveDataFileSystemExtraData(IN uint64_t _0, OUT void * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::ReadSaveDataFileSystemExtraDataWithSpaceId(IN uint8_t _0, IN uint64_t _1, OUT void * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::RegisterExternalKey(IN uint128_t _0, IN uint128_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::RegisterSaveDataAtomicDeletion(IN void * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::SetBisRootForHost(IN uint32_t _0, IN int8_t * path, guint path_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::SetCurrentPosixTime(IN uint64_t time) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::SetGlobalAccessLogMode(IN uint32_t mode) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::SetSaveDataRootPath(IN int8_t * path, guint path_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::SetSaveDataSize(IN uint64_t _0, IN uint64_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::SetSdCardEncryptionSeed(IN uint128_t seedmaybe) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::UnregisterExternalKey() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::VerifySaveData(IN nn::ApplicationId tid, OUT void * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxy::WriteSaveDataFileSystemExtraData(IN uint64_t _0, IN uint8_t _1, IN void * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxyForLoader::IsCodeMounted(IN nn::ApplicationId TID, OUT uint8_t& isMounted) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IFileSystemProxyForLoader::MountCode(IN nn::ApplicationId TID, IN int8_t * contentPath, guint contentPath_size, OUT nn::fssrv::sf::IFileSystem * contentFs) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + contentFs OMG = new nn::fssrv::sf::IFileSystem(resp.move_handles[0]); + return ret; +} +uint32_t nn::fssrv::sf::IProgramRegistry::ClearFsPermissions(IN uint64_t pid) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IProgramRegistry::SetEnabledProgramVerification(IN uint8_t enabled) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IProgramRegistry::SetFsPermissions(IN uint64_t _0, IN uint64_t _1, IN uint8_t _2, IN uint64_t _3, IN uint64_t _4, IN uint8_t * _5, guint _5_size, IN uint8_t * _6, guint _6_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(5, 1, temp5); + ctu->cpu.readmem(temp4, temp6, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + delete[] temp6; + return ret; +} +uint32_t nn::fssrv::sf::ISaveDataInfoReader::Unknown0(OUT uint64_t& _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::fssrv::sf::IStorage::Flush() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IStorage::GetSize(OUT uint64_t& size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IStorage::Read(IN uint64_t offset, IN uint64_t length, OUT int8_t * buffer, guint buffer_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x46, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::fssrv::sf::IStorage::SetSize(IN uint64_t size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::fssrv::sf::IStorage::Write(IN uint64_t offset, IN uint64_t length, IN int8_t * data, guint data_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x45, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::gpio { + class IManager { + public: + IManager(); + uint32_t GetPadSession(IN uint32_t _0, OUT nn::gpio::IPadSession * _1); + uint32_t Unknown0(IN uint32_t _0, OUT IUnknown * _1); + uint32_t Unknown2(IN uint32_t _0, OUT IUnknown * _1); + uint32_t Unknown3(IN uint32_t _0, OUT uint8_t& _1); + uint32_t Unknown4(OUT uint128_t& _0); + uint32_t Unknown5(IN uint32_t _0, IN uint8_t _1); + uint32_t Unknown6(IN uint8_t _0); + }; + class IPadSession { + public: + IPadSession(); + uint32_t Unknown0(IN uint32_t _0); + uint32_t Unknown1(OUT uint32_t& _0); + uint32_t Unknown10(OUT KObject * _0); + uint32_t Unknown11(); + uint32_t Unknown12(IN uint8_t _0); + uint32_t Unknown13(OUT uint8_t& _0); + uint32_t Unknown14(IN uint32_t _0); + uint32_t Unknown15(OUT uint32_t& _0); + uint32_t Unknown2(IN uint32_t _0); + uint32_t Unknown3(OUT uint32_t& _0); + uint32_t Unknown4(IN uint8_t _0); + uint32_t Unknown5(OUT uint8_t& _0); + uint32_t Unknown6(OUT uint32_t& _0); + uint32_t Unknown7(); + uint32_t Unknown8(IN uint32_t _0); + uint32_t Unknown9(OUT uint32_t& _0); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::gpio::IManager::GetPadSession(IN uint32_t _0, OUT nn::gpio::IPadSession * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new nn::gpio::IPadSession(resp.move_handles[0]); + return ret; +} +uint32_t nn::gpio::IManager::Unknown0(IN uint32_t _0, OUT IUnknown * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new IUnknown(resp.move_handles[0]); + return ret; +} +uint32_t nn::gpio::IManager::Unknown2(IN uint32_t _0, OUT IUnknown * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new IUnknown(resp.move_handles[0]); + return ret; +} +uint32_t nn::gpio::IManager::Unknown3(IN uint32_t _0, OUT uint8_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::gpio::IManager::Unknown4(OUT uint128_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::gpio::IManager::Unknown5(IN uint32_t _0, IN uint8_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::gpio::IManager::Unknown6(IN uint8_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::gpio::IPadSession::Unknown0(IN uint32_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::gpio::IPadSession::Unknown1(OUT uint32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::gpio::IPadSession::Unknown10(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::gpio::IPadSession::Unknown11() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::gpio::IPadSession::Unknown12(IN uint8_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::gpio::IPadSession::Unknown13(OUT uint8_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::gpio::IPadSession::Unknown14(IN uint32_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::gpio::IPadSession::Unknown15(OUT uint32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::gpio::IPadSession::Unknown2(IN uint32_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::gpio::IPadSession::Unknown3(OUT uint32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::gpio::IPadSession::Unknown4(IN uint8_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::gpio::IPadSession::Unknown5(OUT uint8_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::gpio::IPadSession::Unknown6(OUT uint32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::gpio::IPadSession::Unknown7() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::gpio::IPadSession::Unknown8(IN uint32_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::gpio::IPadSession::Unknown9(OUT uint32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::hid { + class IActiveVibrationDeviceList { + public: + IActiveVibrationDeviceList(); + uint32_t ActivateVibrationDevice(IN nn::hid::VibrationDeviceHandle _0); + }; + class IAppletResource { + public: + IAppletResource(); + uint32_t GetSharedMemoryHandle(OUT KObject * _0); + }; + class IHidDebugServer { + public: + IHidDebugServer(); + uint32_t ActivateFirmwareUpdate(); + uint32_t DeactivateCaptureButton(); + uint32_t DeactivateConsoleSixAxisSensor(); + uint32_t DeactivateDebugPad(); + uint32_t DeactivateFirmwareUpdate(); + uint32_t DeactivateGesture(); + uint32_t DeactivateHomeButton(); + uint32_t DeactivateInputDetector(); + uint32_t DeactivateJoyXpad(IN nn::hid::JoyXpadId _0); + uint32_t DeactivateKeyboard(); + uint32_t DeactivateMouse(); + uint32_t DeactivateSleepButton(); + uint32_t DeactivateTouchScreen(); + uint32_t DeactivateXpad(IN nn::hid::BasicXpadId _0); + uint32_t DiscardFirmwareInfoCacheForRevert(); + uint32_t GetAvailableFirmwareVersionForRevert(IN nn::hid::system::UniquePadId _0, OUT nn::hid::system::FirmwareVersion& _1); + uint32_t GetDestinationFirmwareVersion(IN uint32_t _0, IN nn::hid::system::DeviceType _1, OUT nn::hid::system::FirmwareVersion& _2); + uint32_t GetFirmwareUpdateStage(OUT int64_t& _0, OUT int64_t& _1); + uint32_t GetFirmwareVersion(IN uint32_t _0, IN nn::hid::system::DeviceType _1, OUT nn::hid::system::FirmwareVersion& _2); + uint32_t GetShiftAccelerometerCalibrationValue(IN nn::hid::SixAxisSensorHandle _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2, OUT float32_t& _3, OUT float32_t& _4); + uint32_t GetShiftGyroscopeCalibrationValue(IN nn::hid::SixAxisSensorHandle _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2, OUT float32_t& _3, OUT float32_t& _4); + uint32_t SetCaptureButtonAutoPilotState(IN nn::hid::debug::CaptureButtonAutoPilotState _0); + uint32_t SetDebugPadAutoPilotState(IN nn::hid::debug::DebugPadAutoPilotState _0); + uint32_t SetHomeButtonAutoPilotState(IN nn::hid::debug::HomeButtonAutoPilotState _0); + uint32_t SetKeyboardAutoPilotState(IN nn::hid::debug::KeyboardAutoPilotState _0); + uint32_t SetMouseAutoPilotState(IN nn::hid::debug::MouseAutoPilotState _0); + uint32_t SetShiftAccelerometerCalibrationValue(IN nn::hid::SixAxisSensorHandle _0, IN float32_t _1, IN float32_t _2, IN nn::applet::AppletResourceUserId _3, IN gpid _4); + uint32_t SetShiftGyroscopeCalibrationValue(IN nn::hid::SixAxisSensorHandle _0, IN float32_t _1, IN float32_t _2, IN nn::applet::AppletResourceUserId _3, IN gpid _4); + uint32_t SetSleepButtonAutoPilotState(IN nn::hid::debug::SleepButtonAutoPilotState _0); + uint32_t SetTouchScreenAutoPilotState(IN nn::hid::TouchState * _0, guint _0_size); + uint32_t SetXpadAutoPilotState(IN nn::hid::BasicXpadId _0, IN nn::hid::debug::BasicXpadAutoPilotState _1); + uint32_t StartFirmwareUpdate(IN nn::hid::system::UniquePadId _0); + uint32_t StartFirmwareUpdateForRevert(IN nn::hid::system::UniquePadId _0); + uint32_t UnsetCaptureButtonAutoPilotState(); + uint32_t UnsetDebugPadAutoPilotState(); + uint32_t UnsetHomeButtonAutoPilotState(); + uint32_t UnsetKeyboardAutoPilotState(); + uint32_t UnsetMouseAutoPilotState(); + uint32_t UnsetSleepButtonAutoPilotState(); + uint32_t UnsetTouchScreenAutoPilotState(); + uint32_t UnsetXpadAutoPilotState(IN nn::hid::BasicXpadId _0); + uint32_t UpdateControllerColor(IN nn::util::Unorm8x4 _0, IN nn::util::Unorm8x4 _1, IN nn::hid::system::UniquePadId _2); + }; + class IHidServer { + public: + IHidServer(); + uint32_t AcquireNpadStyleSetUpdateEventHandle(IN uint32_t _0, IN nn::applet::AppletResourceUserId _1, IN uint64_t _2, IN gpid _3, OUT KObject * _4); + uint32_t AcquireXpadIdEventHandle(IN uint64_t _0, OUT KObject * _1); + uint32_t ActivateConsoleSixAxisSensor(IN nn::applet::AppletResourceUserId _0, IN gpid _1); + uint32_t ActivateDebugPad(IN nn::applet::AppletResourceUserId _0, IN gpid _1); + uint32_t ActivateGesture(IN int32_t _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2); + uint32_t ActivateJoySixAxisSensor(IN nn::hid::JoyXpadId _0); + uint32_t ActivateJoyXpad(IN nn::hid::JoyXpadId _0); + uint32_t ActivateKeyboard(IN nn::applet::AppletResourceUserId _0, IN gpid _1); + uint32_t ActivateMouse(IN nn::applet::AppletResourceUserId _0, IN gpid _1); + uint32_t ActivateNpad(IN nn::applet::AppletResourceUserId _0, IN gpid _1); + uint32_t ActivateSixAxisSensor(IN nn::hid::BasicXpadId _0); + uint32_t ActivateTouchScreen(IN nn::applet::AppletResourceUserId _0, IN gpid _1); + uint32_t ActivateXpad(IN nn::hid::BasicXpadId _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2); + uint32_t CreateActiveVibrationDeviceList(OUT nn::hid::IActiveVibrationDeviceList * _0); + uint32_t CreateAppletResource(IN nn::applet::AppletResourceUserId _0, IN gpid _1, OUT nn::hid::IAppletResource * _2); + uint32_t DeactivateJoySixAxisSensor(IN nn::hid::JoyXpadId _0); + uint32_t DeactivateNpad(IN nn::applet::AppletResourceUserId _0, IN gpid _1); + uint32_t DeactivateSixAxisSensor(IN nn::hid::BasicXpadId _0); + uint32_t DisconnectNpad(IN uint32_t _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2); + uint32_t EnableSixAxisSensorFusion(IN bool _0, IN nn::hid::SixAxisSensorHandle _1, IN nn::applet::AppletResourceUserId _2, IN gpid _3); + uint32_t EnableUnintendedHomeButtonInputProtection(IN bool _0, IN uint32_t _1, IN nn::applet::AppletResourceUserId _2, IN gpid _3); + uint32_t EnableUsbFullKeyController(IN bool _0); + uint32_t GetAccelerometerParameters(IN nn::hid::SixAxisSensorHandle _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2, OUT float32_t& _3, OUT float32_t& _4); + uint32_t GetAccelerometerPlayMode(IN nn::hid::SixAxisSensorHandle _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2, OUT uint32_t& _3); + uint32_t GetActualVibrationValue(IN nn::hid::VibrationDeviceHandle _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2, OUT nn::hid::VibrationValue& _3); + uint32_t GetGyroscopeZeroDriftMode(IN nn::hid::SixAxisSensorHandle _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2, OUT uint32_t& _3); + uint32_t GetJoySixAxisSensorLifoHandle(IN nn::hid::JoyXpadId _0, OUT KObject * _1); + uint32_t GetJoyXpadIds(OUT int64_t& _0, OUT nn::hid::JoyXpadId * _1, guint _1_size); + uint32_t GetJoyXpadLifoHandle(IN nn::hid::JoyXpadId _0, OUT KObject * _1); + uint32_t GetNpadCommunicationMode(OUT int64_t& _0); + uint32_t GetNpadHandheldActivationMode(IN nn::applet::AppletResourceUserId _0, IN gpid _1, OUT int64_t& _2); + uint32_t GetNpadJoyHoldType(IN nn::applet::AppletResourceUserId _0, IN gpid _1, OUT int64_t& _2); + uint32_t GetPlayerLedPattern(IN uint32_t _0, OUT uint64_t& _1); + uint32_t GetSixAxisSensorFusionParameters(IN nn::hid::SixAxisSensorHandle _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2, OUT float32_t& _3, OUT float32_t& _4); + uint32_t GetSixAxisSensorLifoHandle(IN nn::hid::BasicXpadId _0, OUT KObject * _1); + uint32_t GetSupportedNpadStyleSet(IN nn::applet::AppletResourceUserId _0, IN gpid _1, OUT nn::hid::NpadStyleTag& _2); + uint32_t GetVibrationDeviceInfo(IN nn::hid::VibrationDeviceHandle _0, OUT nn::hid::VibrationDeviceInfoForIpc& _1); + uint32_t GetXpadIds(OUT int64_t& _0, OUT nn::hid::BasicXpadId * _1, guint _1_size); + uint32_t IsSixAxisSensorAtRest(IN nn::hid::SixAxisSensorHandle _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2, OUT bool& _3); + uint32_t IsSixAxisSensorFusionEnabled(IN nn::hid::SixAxisSensorHandle _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2, OUT bool& _3); + uint32_t IsUnintendedHomeButtonInputProtectionEnabled(IN uint32_t _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2, OUT bool& _3); + uint32_t IsUsbFullKeyControllerConnected(IN uint32_t _0, OUT bool& _1); + uint32_t IsUsbFullKeyControllerEnabled(OUT bool& _0); + uint32_t IsVibrationPermitted(OUT bool& _0); + uint32_t MergeSingleJoyAsDualJoy(IN uint32_t _0, IN uint32_t _1, IN nn::applet::AppletResourceUserId _2, IN gpid _3); + uint32_t PermitVibration(IN bool _0); + uint32_t ReleaseXpadIdEventHandle(IN uint64_t _0); + uint32_t ResetAccelerometerParameters(IN nn::hid::SixAxisSensorHandle _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2); + uint32_t ResetAccelerometerPlayMode(IN nn::hid::SixAxisSensorHandle _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2); + uint32_t ResetGyroscopeZeroDriftMode(IN nn::hid::SixAxisSensorHandle _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2); + uint32_t ResetSixAxisSensorFusionParameters(IN nn::hid::SixAxisSensorHandle _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2); + uint32_t SendVibrationValue(IN nn::hid::VibrationDeviceHandle _0, IN nn::hid::VibrationValue _1, IN nn::applet::AppletResourceUserId _2, IN gpid _3); + uint32_t SendVibrationValues(IN nn::applet::AppletResourceUserId _0, IN nn::hid::VibrationDeviceHandle * _1, guint _1_size, IN nn::hid::VibrationValue * _2, guint _2_size); + uint32_t SetAccelerometerParameters(IN nn::hid::SixAxisSensorHandle _0, IN float32_t _1, IN float32_t _2, IN nn::applet::AppletResourceUserId _3, IN gpid _4); + uint32_t SetAccelerometerPlayMode(IN nn::hid::SixAxisSensorHandle _0, IN uint32_t _1, IN nn::applet::AppletResourceUserId _2, IN gpid _3); + uint32_t SetGyroscopeZeroDriftMode(IN nn::hid::SixAxisSensorHandle _0, IN uint32_t _1, IN nn::applet::AppletResourceUserId _2, IN gpid _3); + uint32_t SetNpadCommunicationMode(IN nn::applet::AppletResourceUserId _0, IN int64_t _1, IN gpid _2); + uint32_t SetNpadHandheldActivationMode(IN nn::applet::AppletResourceUserId _0, IN int64_t _1, IN gpid _2); + uint32_t SetNpadJoyAssignmentModeDual(IN uint32_t _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2); + uint32_t SetNpadJoyAssignmentModeSingle(IN uint32_t _0, IN nn::applet::AppletResourceUserId _1, IN int64_t _2, IN gpid _3); + uint32_t SetNpadJoyAssignmentModeSingleByDefault(IN uint32_t _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2); + uint32_t SetNpadJoyHoldType(IN nn::applet::AppletResourceUserId _0, IN int64_t _1, IN gpid _2); + uint32_t SetSixAxisSensorFusionParameters(IN nn::hid::SixAxisSensorHandle _0, IN float32_t _1, IN float32_t _2, IN nn::applet::AppletResourceUserId _3, IN gpid _4); + uint32_t SetSupportedNpadIdType(IN nn::applet::AppletResourceUserId _0, IN gpid _1, IN uint32_t * _2, guint _2_size); + uint32_t SetSupportedNpadStyleSet(IN nn::hid::NpadStyleTag _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2); + uint32_t StartConsoleSixAxisSensor(IN nn::hid::ConsoleSixAxisSensorHandle _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2); + uint32_t StartLrAssignmentMode(IN nn::applet::AppletResourceUserId _0, IN gpid _1); + uint32_t StartSixAxisSensor(IN nn::hid::SixAxisSensorHandle _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2); + uint32_t StopConsoleSixAxisSensor(IN nn::hid::ConsoleSixAxisSensorHandle _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2); + uint32_t StopLrAssignmentMode(IN nn::applet::AppletResourceUserId _0, IN gpid _1); + uint32_t StopSixAxisSensor(IN nn::hid::SixAxisSensorHandle _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2); + uint32_t SwapNpadAssignment(IN uint32_t _0, IN uint32_t _1, IN nn::applet::AppletResourceUserId _2, IN gpid _3); + }; + class IHidSystemServer { + public: + IHidSystemServer(); + uint32_t AbortFirmwareUpdate(); + uint32_t AcquireCaptureButtonEventHandle(IN nn::applet::AppletResourceUserId _0, IN gpid _1, OUT KObject * _2); + uint32_t AcquireConnectionTriggerTimeoutEvent(OUT KObject * _0); + uint32_t AcquireDeviceRegisteredEventForControllerSupport(OUT KObject * _0); + uint32_t AcquireHomeButtonEventHandle(IN nn::applet::AppletResourceUserId _0, IN gpid _1, OUT KObject * _2); + uint32_t AcquireIrSensorEventHandle(IN uint32_t _0, OUT KObject * _1); + uint32_t AcquireJoyDetachOnBluetoothOffEventHandle(IN nn::applet::AppletResourceUserId _0, IN gpid _1, OUT KObject * _2); + uint32_t AcquireNfcActivateEventHandle(IN uint32_t _0, OUT KObject * _1); + uint32_t AcquireNfcDeviceUpdateEventHandle(OUT KObject * _0); + uint32_t AcquirePlayReportControllerUsageUpdateEvent(OUT KObject * _0); + uint32_t AcquirePlayReportRegisteredDeviceUpdateEvent(OUT KObject * _0); + uint32_t AcquireSleepButtonEventHandle(IN nn::applet::AppletResourceUserId _0, IN gpid _1, OUT KObject * _2); + uint32_t AcquireUniquePadConnectionEventHandle(OUT KObject * _0); + uint32_t ActivateCaptureButton(IN nn::applet::AppletResourceUserId _0, IN gpid _1); + uint32_t ActivateHomeButton(IN nn::applet::AppletResourceUserId _0, IN gpid _1); + uint32_t ActivateInputDetector(IN nn::applet::AppletResourceUserId _0, IN gpid _1); + uint32_t ActivateIrSensor(IN bool _0, IN uint32_t _1, IN nn::applet::AppletResourceUserId _2, IN gpid _3); + uint32_t ActivateNfc(IN bool _0, IN uint32_t _1, IN nn::applet::AppletResourceUserId _2, IN gpid _3); + uint32_t ActivateNpadSystem(IN uint32_t _0); + uint32_t ActivateSleepButton(IN nn::applet::AppletResourceUserId _0, IN gpid _1); + uint32_t ActivateUniquePad(IN nn::applet::AppletResourceUserId _0, IN nn::hid::system::UniquePadId _1, IN gpid _2); + uint32_t ApplyNpadSystemCommonPolicy(IN nn::applet::AppletResourceUserId _0, IN gpid _1); + uint32_t BeginPermitVibrationSession(IN nn::applet::AppletResourceUserId _0); + uint32_t CancelAnalogStickManualCalibration(IN nn::hid::system::UniquePadId _0, IN int64_t _1); + uint32_t CancelSixAxisSensorUserCalibration(IN nn::hid::system::UniqueSixAxisSensorHandle _0); + uint32_t CheckFirmwareUpdateRequired(IN nn::hid::system::UniquePadId _0, OUT int64_t& _1); + uint32_t DisableAssigningSingleOnSlSrPress(IN nn::applet::AppletResourceUserId _0, IN gpid _1); + uint32_t DisableHandheldHids(); + uint32_t DisconnectUniquePad(IN nn::hid::system::UniquePadId _0); + uint32_t EnableAppletToGetInput(IN bool _0, IN nn::applet::AppletResourceUserId _1); + uint32_t EnableAppletToGetSixAxisSensor(IN bool _0, IN nn::applet::AppletResourceUserId _1); + uint32_t EnableAssigningSingleOnSlSrPress(IN nn::applet::AppletResourceUserId _0, IN gpid _1); + uint32_t EnableHandheldHids(); + uint32_t EnableUsbFullKeyController(IN bool _0); + uint32_t EndPermitVibrationSession(); + uint32_t GetAllowedBluetoothLinksCount(OUT int64_t& _0); + uint32_t GetAvailableFirmwareVersion(IN nn::hid::system::UniquePadId _0, OUT nn::hid::system::FirmwareVersion& _1); + uint32_t GetFirmwareUpdateState(IN nn::hid::system::FirmwareUpdateDeviceHandle _0, OUT nn::hid::system::FirmwareUpdateState& _1); + uint32_t GetFirmwareVersion(IN nn::hid::system::UniquePadId _0, OUT nn::hid::system::FirmwareVersion& _1); + uint32_t GetIrSensorState(IN uint32_t _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2, OUT int64_t& _3); + uint32_t GetLastActiveNpad(OUT uint32_t& _0); + uint32_t GetNpadSystemExtStyle(IN uint32_t _0, OUT int64_t& _1, OUT int64_t& _2); + uint32_t GetNpadsWithNfc(OUT int64_t& _0, OUT uint32_t * _1, guint _1_size); + uint32_t GetPlayReportControllerUsages(OUT int64_t& _0, OUT nn::hid::system::PlayReportControllerUsage * _1, guint _1_size); + uint32_t GetRegisteredDevices(OUT int64_t& _0, OUT nn::hid::system::RegisteredDevice * _1, guint _1_size); + uint32_t GetUniquePadBluetoothAddress(IN nn::hid::system::UniquePadId _0, OUT nn::bluetooth::Address& _1); + uint32_t GetUniquePadIds(OUT int64_t& _0, OUT nn::hid::system::UniquePadId * _1, guint _1_size); + uint32_t GetUniquePadsFromNpad(IN uint32_t _0, OUT int64_t& _1, OUT nn::hid::system::UniquePadId * _2, guint _2_size); + uint32_t GetVibrationMasterVolume(OUT float32_t& _0); + uint32_t GetXcdHandleForNpadWithIrSensor(IN uint32_t _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2, OUT uint64_t& _3); + uint32_t InitializeFirmwareUpdate(); + uint32_t IsFirmwareUpdateAvailable(IN nn::hid::system::UniquePadId _0, OUT bool& _1); + uint32_t IsSixAxisSensorUserCalibrationSupported(IN nn::hid::system::UniqueSixAxisSensorHandle _0, OUT bool& _1); + uint32_t IsUsbConnected(IN nn::hid::system::UniquePadId _0, OUT bool& _1); + uint32_t IsUsbFullKeyControllerEnabled(OUT bool& _0); + uint32_t ListSixAxisSensorHandles(IN nn::hid::system::UniquePadId _0, OUT int64_t& _1, OUT nn::hid::system::UniqueSixAxisSensorHandle * _2, guint _2_size); + uint32_t NotifyInputDetector(IN nn::hid::system::InputSourceId _0); + uint32_t RegisterAppletResourceUserId(IN bool _0, IN nn::applet::AppletResourceUserId _1); + uint32_t ResetAnalogStickManualCalibration(IN nn::hid::system::UniquePadId _0, IN int64_t _1); + uint32_t ResetSixAxisSensorCalibrationValues(IN nn::hid::system::UniqueSixAxisSensorHandle _0); + uint32_t RetryCurrentAnalogStickManualCalibrationStage(IN nn::hid::system::UniquePadId _0, IN int64_t _1); + uint32_t SendConnectionTrigger(IN nn::bluetooth::Address _0); + uint32_t SendKeyboardLockKeyEvent(IN nn::hid::system::KeyboardLockKeyEvent _0); + uint32_t SetAppletResourceUserId(IN nn::applet::AppletResourceUserId _0); + uint32_t SetAruidValidForVibration(IN bool _0, IN nn::applet::AppletResourceUserId _1); + uint32_t SetNpadPlayerLedBlinkingDevice(IN uint32_t _0, IN nn::hid::system::DeviceType _1, IN nn::applet::AppletResourceUserId _2, IN gpid _3); + uint32_t SetVibrationMasterVolume(IN float32_t _0); + uint32_t StartAnalogStickManualCalibration(IN nn::hid::system::UniquePadId _0, IN int64_t _1); + uint32_t StartFirmwareUpdate(IN nn::hid::system::UniquePadId _0, OUT nn::hid::system::FirmwareUpdateDeviceHandle& _1); + uint32_t StartSixAxisSensorUserCalibration(IN nn::hid::system::UniqueSixAxisSensorHandle _0); + uint32_t UnregisterAppletResourceUserId(IN nn::applet::AppletResourceUserId _0); + }; + class IHidTemporaryServer { + public: + IHidTemporaryServer(); + uint32_t GetConsoleSixAxisSensorCalibrationValues(IN nn::hid::ConsoleSixAxisSensorHandle _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2, OUT nn::hid::tmp::ConsoleSixAxisSensorCalibrationValues& _3); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::hid::IActiveVibrationDeviceList::ActivateVibrationDevice(IN nn::hid::VibrationDeviceHandle _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IAppletResource::GetSharedMemoryHandle(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::hid::IHidDebugServer::ActivateFirmwareUpdate() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidDebugServer::DeactivateCaptureButton() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidDebugServer::DeactivateConsoleSixAxisSensor() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidDebugServer::DeactivateDebugPad() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidDebugServer::DeactivateFirmwareUpdate() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidDebugServer::DeactivateGesture() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidDebugServer::DeactivateHomeButton() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidDebugServer::DeactivateInputDetector() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidDebugServer::DeactivateJoyXpad(IN nn::hid::JoyXpadId _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidDebugServer::DeactivateKeyboard() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidDebugServer::DeactivateMouse() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidDebugServer::DeactivateSleepButton() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidDebugServer::DeactivateTouchScreen() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidDebugServer::DeactivateXpad(IN nn::hid::BasicXpadId _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidDebugServer::DiscardFirmwareInfoCacheForRevert() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidDebugServer::GetAvailableFirmwareVersionForRevert(IN nn::hid::system::UniquePadId _0, OUT nn::hid::system::FirmwareVersion& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidDebugServer::GetDestinationFirmwareVersion(IN uint32_t _0, IN nn::hid::system::DeviceType _1, OUT nn::hid::system::FirmwareVersion& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidDebugServer::GetFirmwareUpdateStage(OUT int64_t& _0, OUT int64_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidDebugServer::GetFirmwareVersion(IN uint32_t _0, IN nn::hid::system::DeviceType _1, OUT nn::hid::system::FirmwareVersion& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidDebugServer::GetShiftAccelerometerCalibrationValue(IN nn::hid::SixAxisSensorHandle _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2, OUT float32_t& _3, OUT float32_t& _4) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidDebugServer::GetShiftGyroscopeCalibrationValue(IN nn::hid::SixAxisSensorHandle _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2, OUT float32_t& _3, OUT float32_t& _4) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidDebugServer::SetCaptureButtonAutoPilotState(IN nn::hid::debug::CaptureButtonAutoPilotState _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidDebugServer::SetDebugPadAutoPilotState(IN nn::hid::debug::DebugPadAutoPilotState _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidDebugServer::SetHomeButtonAutoPilotState(IN nn::hid::debug::HomeButtonAutoPilotState _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidDebugServer::SetKeyboardAutoPilotState(IN nn::hid::debug::KeyboardAutoPilotState _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidDebugServer::SetMouseAutoPilotState(IN nn::hid::debug::MouseAutoPilotState _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidDebugServer::SetShiftAccelerometerCalibrationValue(IN nn::hid::SixAxisSensorHandle _0, IN float32_t _1, IN float32_t _2, IN nn::applet::AppletResourceUserId _3, IN gpid _4) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidDebugServer::SetShiftGyroscopeCalibrationValue(IN nn::hid::SixAxisSensorHandle _0, IN float32_t _1, IN float32_t _2, IN nn::applet::AppletResourceUserId _3, IN gpid _4) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidDebugServer::SetSleepButtonAutoPilotState(IN nn::hid::debug::SleepButtonAutoPilotState _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidDebugServer::SetTouchScreenAutoPilotState(IN nn::hid::TouchState * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::hid::IHidDebugServer::SetXpadAutoPilotState(IN nn::hid::BasicXpadId _0, IN nn::hid::debug::BasicXpadAutoPilotState _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidDebugServer::StartFirmwareUpdate(IN nn::hid::system::UniquePadId _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidDebugServer::StartFirmwareUpdateForRevert(IN nn::hid::system::UniquePadId _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidDebugServer::UnsetCaptureButtonAutoPilotState() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidDebugServer::UnsetDebugPadAutoPilotState() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidDebugServer::UnsetHomeButtonAutoPilotState() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidDebugServer::UnsetKeyboardAutoPilotState() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidDebugServer::UnsetMouseAutoPilotState() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidDebugServer::UnsetSleepButtonAutoPilotState() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidDebugServer::UnsetTouchScreenAutoPilotState() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidDebugServer::UnsetXpadAutoPilotState(IN nn::hid::BasicXpadId _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidDebugServer::UpdateControllerColor(IN nn::util::Unorm8x4 _0, IN nn::util::Unorm8x4 _1, IN nn::hid::system::UniquePadId _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::AcquireNpadStyleSetUpdateEventHandle(IN uint32_t _0, IN nn::applet::AppletResourceUserId _1, IN uint64_t _2, IN gpid _3, OUT KObject * _4) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::hid::IHidServer::AcquireXpadIdEventHandle(IN uint64_t _0, OUT KObject * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::hid::IHidServer::ActivateConsoleSixAxisSensor(IN nn::applet::AppletResourceUserId _0, IN gpid _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::ActivateDebugPad(IN nn::applet::AppletResourceUserId _0, IN gpid _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::ActivateGesture(IN int32_t _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::ActivateJoySixAxisSensor(IN nn::hid::JoyXpadId _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::ActivateJoyXpad(IN nn::hid::JoyXpadId _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::ActivateKeyboard(IN nn::applet::AppletResourceUserId _0, IN gpid _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::ActivateMouse(IN nn::applet::AppletResourceUserId _0, IN gpid _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::ActivateNpad(IN nn::applet::AppletResourceUserId _0, IN gpid _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::ActivateSixAxisSensor(IN nn::hid::BasicXpadId _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::ActivateTouchScreen(IN nn::applet::AppletResourceUserId _0, IN gpid _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::ActivateXpad(IN nn::hid::BasicXpadId _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::CreateActiveVibrationDeviceList(OUT nn::hid::IActiveVibrationDeviceList * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::hid::IActiveVibrationDeviceList(resp.move_handles[0]); + return ret; +} +uint32_t nn::hid::IHidServer::CreateAppletResource(IN nn::applet::AppletResourceUserId _0, IN gpid _1, OUT nn::hid::IAppletResource * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _2 OMG = new nn::hid::IAppletResource(resp.move_handles[0]); + return ret; +} +uint32_t nn::hid::IHidServer::DeactivateJoySixAxisSensor(IN nn::hid::JoyXpadId _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::DeactivateNpad(IN nn::applet::AppletResourceUserId _0, IN gpid _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::DeactivateSixAxisSensor(IN nn::hid::BasicXpadId _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::DisconnectNpad(IN uint32_t _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::EnableSixAxisSensorFusion(IN bool _0, IN nn::hid::SixAxisSensorHandle _1, IN nn::applet::AppletResourceUserId _2, IN gpid _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::EnableUnintendedHomeButtonInputProtection(IN bool _0, IN uint32_t _1, IN nn::applet::AppletResourceUserId _2, IN gpid _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::EnableUsbFullKeyController(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::GetAccelerometerParameters(IN nn::hid::SixAxisSensorHandle _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2, OUT float32_t& _3, OUT float32_t& _4) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::GetAccelerometerPlayMode(IN nn::hid::SixAxisSensorHandle _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2, OUT uint32_t& _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::GetActualVibrationValue(IN nn::hid::VibrationDeviceHandle _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2, OUT nn::hid::VibrationValue& _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::GetGyroscopeZeroDriftMode(IN nn::hid::SixAxisSensorHandle _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2, OUT uint32_t& _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::GetJoySixAxisSensorLifoHandle(IN nn::hid::JoyXpadId _0, OUT KObject * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::hid::IHidServer::GetJoyXpadIds(OUT int64_t& _0, OUT nn::hid::JoyXpadId * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0xa, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::hid::IHidServer::GetJoyXpadLifoHandle(IN nn::hid::JoyXpadId _0, OUT KObject * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::hid::IHidServer::GetNpadCommunicationMode(OUT int64_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::GetNpadHandheldActivationMode(IN nn::applet::AppletResourceUserId _0, IN gpid _1, OUT int64_t& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::GetNpadJoyHoldType(IN nn::applet::AppletResourceUserId _0, IN gpid _1, OUT int64_t& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::GetPlayerLedPattern(IN uint32_t _0, OUT uint64_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::GetSixAxisSensorFusionParameters(IN nn::hid::SixAxisSensorHandle _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2, OUT float32_t& _3, OUT float32_t& _4) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::GetSixAxisSensorLifoHandle(IN nn::hid::BasicXpadId _0, OUT KObject * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::hid::IHidServer::GetSupportedNpadStyleSet(IN nn::applet::AppletResourceUserId _0, IN gpid _1, OUT nn::hid::NpadStyleTag& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::GetVibrationDeviceInfo(IN nn::hid::VibrationDeviceHandle _0, OUT nn::hid::VibrationDeviceInfoForIpc& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::GetXpadIds(OUT int64_t& _0, OUT nn::hid::BasicXpadId * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0xa, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::hid::IHidServer::IsSixAxisSensorAtRest(IN nn::hid::SixAxisSensorHandle _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2, OUT bool& _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::IsSixAxisSensorFusionEnabled(IN nn::hid::SixAxisSensorHandle _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2, OUT bool& _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::IsUnintendedHomeButtonInputProtectionEnabled(IN uint32_t _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2, OUT bool& _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::IsUsbFullKeyControllerConnected(IN uint32_t _0, OUT bool& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::IsUsbFullKeyControllerEnabled(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::IsVibrationPermitted(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::MergeSingleJoyAsDualJoy(IN uint32_t _0, IN uint32_t _1, IN nn::applet::AppletResourceUserId _2, IN gpid _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::PermitVibration(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::ReleaseXpadIdEventHandle(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::ResetAccelerometerParameters(IN nn::hid::SixAxisSensorHandle _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::ResetAccelerometerPlayMode(IN nn::hid::SixAxisSensorHandle _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::ResetGyroscopeZeroDriftMode(IN nn::hid::SixAxisSensorHandle _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::ResetSixAxisSensorFusionParameters(IN nn::hid::SixAxisSensorHandle _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::SendVibrationValue(IN nn::hid::VibrationDeviceHandle _0, IN nn::hid::VibrationValue _1, IN nn::applet::AppletResourceUserId _2, IN gpid _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::SendVibrationValues(IN nn::applet::AppletResourceUserId _0, IN nn::hid::VibrationDeviceHandle * _1, guint _1_size, IN nn::hid::VibrationValue * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(9, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(9, 1, temp5); + ctu->cpu.readmem(temp4, temp6, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + delete[] temp6; + return ret; +} +uint32_t nn::hid::IHidServer::SetAccelerometerParameters(IN nn::hid::SixAxisSensorHandle _0, IN float32_t _1, IN float32_t _2, IN nn::applet::AppletResourceUserId _3, IN gpid _4) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::SetAccelerometerPlayMode(IN nn::hid::SixAxisSensorHandle _0, IN uint32_t _1, IN nn::applet::AppletResourceUserId _2, IN gpid _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::SetGyroscopeZeroDriftMode(IN nn::hid::SixAxisSensorHandle _0, IN uint32_t _1, IN nn::applet::AppletResourceUserId _2, IN gpid _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::SetNpadCommunicationMode(IN nn::applet::AppletResourceUserId _0, IN int64_t _1, IN gpid _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::SetNpadHandheldActivationMode(IN nn::applet::AppletResourceUserId _0, IN int64_t _1, IN gpid _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::SetNpadJoyAssignmentModeDual(IN uint32_t _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::SetNpadJoyAssignmentModeSingle(IN uint32_t _0, IN nn::applet::AppletResourceUserId _1, IN int64_t _2, IN gpid _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::SetNpadJoyAssignmentModeSingleByDefault(IN uint32_t _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::SetNpadJoyHoldType(IN nn::applet::AppletResourceUserId _0, IN int64_t _1, IN gpid _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::SetSixAxisSensorFusionParameters(IN nn::hid::SixAxisSensorHandle _0, IN float32_t _1, IN float32_t _2, IN nn::applet::AppletResourceUserId _3, IN gpid _4) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::SetSupportedNpadIdType(IN nn::applet::AppletResourceUserId _0, IN gpid _1, IN uint32_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(9, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::hid::IHidServer::SetSupportedNpadStyleSet(IN nn::hid::NpadStyleTag _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::StartConsoleSixAxisSensor(IN nn::hid::ConsoleSixAxisSensorHandle _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::StartLrAssignmentMode(IN nn::applet::AppletResourceUserId _0, IN gpid _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::StartSixAxisSensor(IN nn::hid::SixAxisSensorHandle _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::StopConsoleSixAxisSensor(IN nn::hid::ConsoleSixAxisSensorHandle _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::StopLrAssignmentMode(IN nn::applet::AppletResourceUserId _0, IN gpid _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::StopSixAxisSensor(IN nn::hid::SixAxisSensorHandle _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidServer::SwapNpadAssignment(IN uint32_t _0, IN uint32_t _1, IN nn::applet::AppletResourceUserId _2, IN gpid _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::AbortFirmwareUpdate() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::AcquireCaptureButtonEventHandle(IN nn::applet::AppletResourceUserId _0, IN gpid _1, OUT KObject * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::hid::IHidSystemServer::AcquireConnectionTriggerTimeoutEvent(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::hid::IHidSystemServer::AcquireDeviceRegisteredEventForControllerSupport(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::hid::IHidSystemServer::AcquireHomeButtonEventHandle(IN nn::applet::AppletResourceUserId _0, IN gpid _1, OUT KObject * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::hid::IHidSystemServer::AcquireIrSensorEventHandle(IN uint32_t _0, OUT KObject * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::hid::IHidSystemServer::AcquireJoyDetachOnBluetoothOffEventHandle(IN nn::applet::AppletResourceUserId _0, IN gpid _1, OUT KObject * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::hid::IHidSystemServer::AcquireNfcActivateEventHandle(IN uint32_t _0, OUT KObject * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::hid::IHidSystemServer::AcquireNfcDeviceUpdateEventHandle(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::hid::IHidSystemServer::AcquirePlayReportControllerUsageUpdateEvent(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::hid::IHidSystemServer::AcquirePlayReportRegisteredDeviceUpdateEvent(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::hid::IHidSystemServer::AcquireSleepButtonEventHandle(IN nn::applet::AppletResourceUserId _0, IN gpid _1, OUT KObject * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::hid::IHidSystemServer::AcquireUniquePadConnectionEventHandle(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::hid::IHidSystemServer::ActivateCaptureButton(IN nn::applet::AppletResourceUserId _0, IN gpid _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::ActivateHomeButton(IN nn::applet::AppletResourceUserId _0, IN gpid _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::ActivateInputDetector(IN nn::applet::AppletResourceUserId _0, IN gpid _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::ActivateIrSensor(IN bool _0, IN uint32_t _1, IN nn::applet::AppletResourceUserId _2, IN gpid _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::ActivateNfc(IN bool _0, IN uint32_t _1, IN nn::applet::AppletResourceUserId _2, IN gpid _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::ActivateNpadSystem(IN uint32_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::ActivateSleepButton(IN nn::applet::AppletResourceUserId _0, IN gpid _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::ActivateUniquePad(IN nn::applet::AppletResourceUserId _0, IN nn::hid::system::UniquePadId _1, IN gpid _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::ApplyNpadSystemCommonPolicy(IN nn::applet::AppletResourceUserId _0, IN gpid _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::BeginPermitVibrationSession(IN nn::applet::AppletResourceUserId _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::CancelAnalogStickManualCalibration(IN nn::hid::system::UniquePadId _0, IN int64_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::CancelSixAxisSensorUserCalibration(IN nn::hid::system::UniqueSixAxisSensorHandle _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::CheckFirmwareUpdateRequired(IN nn::hid::system::UniquePadId _0, OUT int64_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::DisableAssigningSingleOnSlSrPress(IN nn::applet::AppletResourceUserId _0, IN gpid _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::DisableHandheldHids() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::DisconnectUniquePad(IN nn::hid::system::UniquePadId _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::EnableAppletToGetInput(IN bool _0, IN nn::applet::AppletResourceUserId _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::EnableAppletToGetSixAxisSensor(IN bool _0, IN nn::applet::AppletResourceUserId _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::EnableAssigningSingleOnSlSrPress(IN nn::applet::AppletResourceUserId _0, IN gpid _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::EnableHandheldHids() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::EnableUsbFullKeyController(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::EndPermitVibrationSession() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::GetAllowedBluetoothLinksCount(OUT int64_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::GetAvailableFirmwareVersion(IN nn::hid::system::UniquePadId _0, OUT nn::hid::system::FirmwareVersion& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::GetFirmwareUpdateState(IN nn::hid::system::FirmwareUpdateDeviceHandle _0, OUT nn::hid::system::FirmwareUpdateState& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::GetFirmwareVersion(IN nn::hid::system::UniquePadId _0, OUT nn::hid::system::FirmwareVersion& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::GetIrSensorState(IN uint32_t _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2, OUT int64_t& _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::GetLastActiveNpad(OUT uint32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::GetNpadSystemExtStyle(IN uint32_t _0, OUT int64_t& _1, OUT int64_t& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::GetNpadsWithNfc(OUT int64_t& _0, OUT uint32_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0xa, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::hid::IHidSystemServer::GetPlayReportControllerUsages(OUT int64_t& _0, OUT nn::hid::system::PlayReportControllerUsage * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0xa, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::hid::IHidSystemServer::GetRegisteredDevices(OUT int64_t& _0, OUT nn::hid::system::RegisteredDevice * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0xa, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::hid::IHidSystemServer::GetUniquePadBluetoothAddress(IN nn::hid::system::UniquePadId _0, OUT nn::bluetooth::Address& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(0xc); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::GetUniquePadIds(OUT int64_t& _0, OUT nn::hid::system::UniquePadId * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0xa, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::hid::IHidSystemServer::GetUniquePadsFromNpad(IN uint32_t _0, OUT int64_t& _1, OUT nn::hid::system::UniquePadId * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0xa, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::hid::IHidSystemServer::GetVibrationMasterVolume(OUT float32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::GetXcdHandleForNpadWithIrSensor(IN uint32_t _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2, OUT uint64_t& _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::InitializeFirmwareUpdate() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::IsFirmwareUpdateAvailable(IN nn::hid::system::UniquePadId _0, OUT bool& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::IsSixAxisSensorUserCalibrationSupported(IN nn::hid::system::UniqueSixAxisSensorHandle _0, OUT bool& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::IsUsbConnected(IN nn::hid::system::UniquePadId _0, OUT bool& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::IsUsbFullKeyControllerEnabled(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::ListSixAxisSensorHandles(IN nn::hid::system::UniquePadId _0, OUT int64_t& _1, OUT nn::hid::system::UniqueSixAxisSensorHandle * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0xa, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::hid::IHidSystemServer::NotifyInputDetector(IN nn::hid::system::InputSourceId _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::RegisterAppletResourceUserId(IN bool _0, IN nn::applet::AppletResourceUserId _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::ResetAnalogStickManualCalibration(IN nn::hid::system::UniquePadId _0, IN int64_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::ResetSixAxisSensorCalibrationValues(IN nn::hid::system::UniqueSixAxisSensorHandle _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::RetryCurrentAnalogStickManualCalibrationStage(IN nn::hid::system::UniquePadId _0, IN int64_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::SendConnectionTrigger(IN nn::bluetooth::Address _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::SendKeyboardLockKeyEvent(IN nn::hid::system::KeyboardLockKeyEvent _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::SetAppletResourceUserId(IN nn::applet::AppletResourceUserId _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::SetAruidValidForVibration(IN bool _0, IN nn::applet::AppletResourceUserId _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::SetNpadPlayerLedBlinkingDevice(IN uint32_t _0, IN nn::hid::system::DeviceType _1, IN nn::applet::AppletResourceUserId _2, IN gpid _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::SetVibrationMasterVolume(IN float32_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::StartAnalogStickManualCalibration(IN nn::hid::system::UniquePadId _0, IN int64_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::StartFirmwareUpdate(IN nn::hid::system::UniquePadId _0, OUT nn::hid::system::FirmwareUpdateDeviceHandle& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::StartSixAxisSensorUserCalibration(IN nn::hid::system::UniqueSixAxisSensorHandle _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidSystemServer::UnregisterAppletResourceUserId(IN nn::applet::AppletResourceUserId _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::hid::IHidTemporaryServer::GetConsoleSixAxisSensorCalibrationValues(IN nn::hid::ConsoleSixAxisSensorHandle _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2, OUT nn::hid::tmp::ConsoleSixAxisSensorCalibrationValues& _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::htc::tenv { + class IService { + public: + IService(); + uint32_t Unknown0(IN uint8_t * _0, OUT uint64_t& _1, OUT uint8_t * _2, guint _2_size); + uint32_t Unknown1(IN uint8_t * _0, OUT uint64_t& _1); + uint32_t Unknown2(IN uint64_t _0); + }; + class IServiceManager { + public: + IServiceManager(); + uint32_t Unknown0(IN uint64_t _0, IN gpid _1, OUT IUnknown * _2); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::htc::tenv::IService::Unknown0(IN uint8_t * _0, OUT uint64_t& _1, OUT uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::htc::tenv::IService::Unknown1(IN uint8_t * _0, OUT uint64_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::htc::tenv::IService::Unknown2(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::htc::tenv::IServiceManager::Unknown0(IN uint64_t _0, IN gpid _1, OUT IUnknown * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _2 OMG = new IUnknown(resp.move_handles[0]); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::i2c { + class IManager { + public: + IManager(); + uint32_t Unknown0(IN uint16_t _0, IN uint32_t _1, IN uint32_t _2, IN uint32_t _3, OUT IUnknown * _4); + uint32_t Unknown1(IN uint32_t _0, OUT IUnknown * _1); + uint32_t Unknown2(IN uint32_t _0, OUT uint8_t& _1); + uint32_t Unknown3(IN uint16_t _0, IN uint32_t _1, IN uint32_t _2, IN uint32_t _3, OUT uint8_t& _4); + }; + class ISession { + public: + ISession(); + uint32_t Unknown0(IN uint32_t _0, IN uint8_t * _1, guint _1_size); + uint32_t Unknown1(IN uint32_t _0, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown10(IN uint32_t _0, IN uint8_t * _1, guint _1_size); + uint32_t Unknown11(IN uint32_t _0, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown12(IN uint8_t * _0, guint _0_size, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown2(IN uint8_t * _0, guint _0_size, OUT uint8_t * _1, guint _1_size); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::i2c::IManager::Unknown0(IN uint16_t _0, IN uint32_t _1, IN uint32_t _2, IN uint32_t _3, OUT IUnknown * _4) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _4 OMG = new IUnknown(resp.move_handles[0]); + return ret; +} +uint32_t nn::i2c::IManager::Unknown1(IN uint32_t _0, OUT IUnknown * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new IUnknown(resp.move_handles[0]); + return ret; +} +uint32_t nn::i2c::IManager::Unknown2(IN uint32_t _0, OUT uint8_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::i2c::IManager::Unknown3(IN uint16_t _0, IN uint32_t _1, IN uint32_t _2, IN uint32_t _3, OUT uint8_t& _4) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::i2c::ISession::Unknown0(IN uint32_t _0, IN uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::i2c::ISession::Unknown1(IN uint32_t _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::i2c::ISession::Unknown10(IN uint32_t _0, IN uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x21, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::i2c::ISession::Unknown11(IN uint32_t _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x22, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::i2c::ISession::Unknown12(IN uint8_t * _0, guint _0_size, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(9, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(0x22, 0, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +uint32_t nn::i2c::ISession::Unknown2(IN uint8_t * _0, guint _0_size, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(9, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(6, 0, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::idle::detail { + class IPolicyManagerSystem { + public: + IPolicyManagerSystem(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + uint32_t Unknown5(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::idle::detail::IPolicyManagerSystem::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::idle::detail::IPolicyManagerSystem::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::idle::detail::IPolicyManagerSystem::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::idle::detail::IPolicyManagerSystem::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::idle::detail::IPolicyManagerSystem::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::idle::detail::IPolicyManagerSystem::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::irsensor { + class IIrSensorServer { + public: + IIrSensorServer(); + uint32_t ActivateIrsensor(IN nn::applet::AppletResourceUserId _0, IN gpid _1); + uint32_t CheckFirmwareVersion(IN nn::irsensor::IrCameraHandle _0, IN nn::irsensor::PackedMcuVersion _1, IN nn::applet::AppletResourceUserId _2, IN gpid _3); + uint32_t DeactivateIrsensor(IN nn::applet::AppletResourceUserId _0, IN gpid _1); + uint32_t GetImageTransferProcessorState(IN nn::irsensor::IrCameraHandle _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2, OUT nn::irsensor::ImageTransferProcessorState& _3, OUT uint8_t * _4, guint _4_size); + uint32_t GetIrsensorSharedMemoryHandle(IN nn::applet::AppletResourceUserId _0, IN gpid _1, OUT KObject * _2); + uint32_t GetNpadIrCameraHandle(IN uint32_t _0, OUT nn::irsensor::IrCameraHandle& _1); + uint32_t RunClusteringProcessor(IN nn::irsensor::IrCameraHandle _0, IN nn::applet::AppletResourceUserId _1, IN nn::irsensor::PackedClusteringProcessorConfig _2, IN gpid _3); + uint32_t RunDpdProcessor(IN nn::irsensor::IrCameraHandle _0, IN nn::irsensor::PackedDpdProcessorConfig _1, IN nn::applet::AppletResourceUserId _2, IN gpid _3); + uint32_t RunImageTransferProcessor(IN nn::irsensor::IrCameraHandle _0, IN nn::applet::AppletResourceUserId _1, IN nn::irsensor::PackedImageTransferProcessorConfig _2, IN uint64_t _3, IN gpid _4, IN KObject * _5); + uint32_t RunMomentProcessor(IN nn::irsensor::IrCameraHandle _0, IN nn::applet::AppletResourceUserId _1, IN nn::irsensor::PackedMomentProcessorConfig _2, IN gpid _3); + uint32_t RunTeraPluginProcessor(IN nn::irsensor::IrCameraHandle _0, IN nn::irsensor::PackedTeraPluginProcessorConfig _1, IN nn::applet::AppletResourceUserId _2, IN gpid _3); + uint32_t StopImageProcessor(IN nn::irsensor::IrCameraHandle _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2); + uint32_t SuspendImageProcessor(IN nn::irsensor::IrCameraHandle _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2); + }; + class IIrSensorSystemServer { + public: + IIrSensorSystemServer(); + uint32_t EnableAppletToGetInput(IN bool _0, IN nn::applet::AppletResourceUserId _1); + uint32_t RegisterAppletResourceUserId(IN bool _0, IN nn::applet::AppletResourceUserId _1); + uint32_t SetAppletResourceUserId(IN nn::applet::AppletResourceUserId _0); + uint32_t UnregisterAppletResourceUserId(IN nn::applet::AppletResourceUserId _0); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::irsensor::IIrSensorServer::ActivateIrsensor(IN nn::applet::AppletResourceUserId _0, IN gpid _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::irsensor::IIrSensorServer::CheckFirmwareVersion(IN nn::irsensor::IrCameraHandle _0, IN nn::irsensor::PackedMcuVersion _1, IN nn::applet::AppletResourceUserId _2, IN gpid _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::irsensor::IIrSensorServer::DeactivateIrsensor(IN nn::applet::AppletResourceUserId _0, IN gpid _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::irsensor::IIrSensorServer::GetImageTransferProcessorState(IN nn::irsensor::IrCameraHandle _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2, OUT nn::irsensor::ImageTransferProcessorState& _3, OUT uint8_t * _4, guint _4_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::irsensor::IIrSensorServer::GetIrsensorSharedMemoryHandle(IN nn::applet::AppletResourceUserId _0, IN gpid _1, OUT KObject * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::irsensor::IIrSensorServer::GetNpadIrCameraHandle(IN uint32_t _0, OUT nn::irsensor::IrCameraHandle& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::irsensor::IIrSensorServer::RunClusteringProcessor(IN nn::irsensor::IrCameraHandle _0, IN nn::applet::AppletResourceUserId _1, IN nn::irsensor::PackedClusteringProcessorConfig _2, IN gpid _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::irsensor::IIrSensorServer::RunDpdProcessor(IN nn::irsensor::IrCameraHandle _0, IN nn::irsensor::PackedDpdProcessorConfig _1, IN nn::applet::AppletResourceUserId _2, IN gpid _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::irsensor::IIrSensorServer::RunImageTransferProcessor(IN nn::irsensor::IrCameraHandle _0, IN nn::applet::AppletResourceUserId _1, IN nn::irsensor::PackedImageTransferProcessorConfig _2, IN uint64_t _3, IN gpid _4, IN KObject * _5) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::irsensor::IIrSensorServer::RunMomentProcessor(IN nn::irsensor::IrCameraHandle _0, IN nn::applet::AppletResourceUserId _1, IN nn::irsensor::PackedMomentProcessorConfig _2, IN gpid _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::irsensor::IIrSensorServer::RunTeraPluginProcessor(IN nn::irsensor::IrCameraHandle _0, IN nn::irsensor::PackedTeraPluginProcessorConfig _1, IN nn::applet::AppletResourceUserId _2, IN gpid _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::irsensor::IIrSensorServer::StopImageProcessor(IN nn::irsensor::IrCameraHandle _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::irsensor::IIrSensorServer::SuspendImageProcessor(IN nn::irsensor::IrCameraHandle _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::irsensor::IIrSensorSystemServer::EnableAppletToGetInput(IN bool _0, IN nn::applet::AppletResourceUserId _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::irsensor::IIrSensorSystemServer::RegisterAppletResourceUserId(IN bool _0, IN nn::applet::AppletResourceUserId _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::irsensor::IIrSensorSystemServer::SetAppletResourceUserId(IN nn::applet::AppletResourceUserId _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::irsensor::IIrSensorSystemServer::UnregisterAppletResourceUserId(IN nn::applet::AppletResourceUserId _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::lbl::detail { + class ILblController { + public: + ILblController(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown10(); + uint32_t Unknown11(); + uint32_t Unknown12(); + uint32_t Unknown13(); + uint32_t Unknown14(); + uint32_t Unknown15(); + uint32_t Unknown16(); + uint32_t Unknown17(); + uint32_t Unknown18(); + uint32_t Unknown19(); + uint32_t Unknown2(); + uint32_t Unknown20(); + uint32_t Unknown21(); + uint32_t Unknown22(); + uint32_t Unknown23(); + uint32_t Unknown24(); + uint32_t Unknown25(); + uint32_t Unknown26(); + uint32_t Unknown27(); + uint32_t Unknown28(); + uint32_t Unknown3(); + uint32_t Unknown4(); + uint32_t Unknown5(); + uint32_t Unknown6(); + uint32_t Unknown7(); + uint32_t Unknown8(); + uint32_t Unknown9(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::lbl::detail::ILblController::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::lbl::detail::ILblController::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::lbl::detail::ILblController::Unknown10() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::lbl::detail::ILblController::Unknown11() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::lbl::detail::ILblController::Unknown12() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::lbl::detail::ILblController::Unknown13() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::lbl::detail::ILblController::Unknown14() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::lbl::detail::ILblController::Unknown15() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::lbl::detail::ILblController::Unknown16() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::lbl::detail::ILblController::Unknown17() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::lbl::detail::ILblController::Unknown18() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::lbl::detail::ILblController::Unknown19() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::lbl::detail::ILblController::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::lbl::detail::ILblController::Unknown20() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::lbl::detail::ILblController::Unknown21() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::lbl::detail::ILblController::Unknown22() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::lbl::detail::ILblController::Unknown23() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::lbl::detail::ILblController::Unknown24() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::lbl::detail::ILblController::Unknown25() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::lbl::detail::ILblController::Unknown26() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::lbl::detail::ILblController::Unknown27() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::lbl::detail::ILblController::Unknown28() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::lbl::detail::ILblController::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::lbl::detail::ILblController::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::lbl::detail::ILblController::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::lbl::detail::ILblController::Unknown6() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::lbl::detail::ILblController::Unknown7() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::lbl::detail::ILblController::Unknown8() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::lbl::detail::ILblController::Unknown9() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::ldn::detail { + class IMonitorService { + public: + IMonitorService(); + uint32_t Unknown0(OUT uint32_t& _0); + uint32_t Unknown1(OUT uint8_t * _0, guint _0_size); + uint32_t Unknown100(); + uint32_t Unknown101(); + uint32_t Unknown2(OUT uint32_t& _0, OUT uint32_t& _1); + uint32_t Unknown3(OUT uint16_t& _0); + uint32_t Unknown4(OUT uint8_t * _0); + uint32_t Unknown5(OUT uint8_t * _0); + }; + class IMonitorServiceCreator { + public: + IMonitorServiceCreator(); + uint32_t Unknown0(OUT IUnknown * _0); + }; + class ISystemLocalCommunicationService { + public: + ISystemLocalCommunicationService(); + uint32_t Unknown0(OUT uint32_t& _0); + uint32_t Unknown1(OUT uint8_t * _0, guint _0_size); + uint32_t Unknown100(OUT KObject * _0); + uint32_t Unknown101(OUT uint8_t * _0, guint _0_size, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown102(IN uint16_t _0, IN uint8_t * _1, OUT uint16_t& _2, OUT uint8_t * _3, guint _3_size); + uint32_t Unknown103(IN uint16_t _0, IN uint8_t * _1, OUT uint16_t& _2, OUT uint8_t * _3, guint _3_size); + uint32_t Unknown2(OUT uint32_t& _0, OUT uint32_t& _1); + uint32_t Unknown200(); + uint32_t Unknown201(); + uint32_t Unknown202(IN uint8_t * _0, IN uint8_t * _1, IN uint8_t * _2); + uint32_t Unknown203(IN uint8_t * _0, IN uint8_t * _1, IN uint8_t * _2, IN uint8_t * _3, IN uint8_t * _4, guint _4_size); + uint32_t Unknown204(); + uint32_t Unknown205(IN uint32_t _0); + uint32_t Unknown206(IN uint8_t * _0, guint _0_size); + uint32_t Unknown207(IN uint8_t _0); + uint32_t Unknown208(IN uint8_t * _0); + uint32_t Unknown209(); + uint32_t Unknown3(OUT uint16_t& _0); + uint32_t Unknown300(); + uint32_t Unknown301(); + uint32_t Unknown302(IN uint8_t * _0, IN uint8_t * _1, IN uint32_t _2, IN uint32_t _3, IN uint8_t * _4, guint _4_size); + uint32_t Unknown303(IN uint8_t * _0, IN uint8_t * _1, IN uint8_t * _2, IN uint32_t _3, IN uint32_t _4, IN uint8_t * _5); + uint32_t Unknown304(); + uint32_t Unknown4(OUT uint8_t * _0); + uint32_t Unknown400(IN uint64_t _0, IN gpid _1); + uint32_t Unknown401(); + uint32_t Unknown5(OUT uint8_t * _0); + }; + class ISystemServiceCreator { + public: + ISystemServiceCreator(); + uint32_t Unknown0(OUT IUnknown * _0); + }; + class IUserLocalCommunicationService { + public: + IUserLocalCommunicationService(); + uint32_t Unknown0(OUT uint32_t& _0); + uint32_t Unknown1(OUT uint8_t * _0, guint _0_size); + uint32_t Unknown100(OUT KObject * _0); + uint32_t Unknown101(OUT uint8_t * _0, guint _0_size, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown102(IN uint16_t _0, IN uint8_t * _1, OUT uint16_t& _2, OUT uint8_t * _3, guint _3_size); + uint32_t Unknown103(IN uint16_t _0, IN uint8_t * _1, OUT uint16_t& _2, OUT uint8_t * _3, guint _3_size); + uint32_t Unknown2(OUT uint32_t& _0, OUT uint32_t& _1); + uint32_t Unknown200(); + uint32_t Unknown201(); + uint32_t Unknown202(IN uint8_t * _0, IN uint8_t * _1, IN uint8_t * _2); + uint32_t Unknown203(IN uint8_t * _0, IN uint8_t * _1, IN uint8_t * _2, IN uint8_t * _3, IN uint8_t * _4, guint _4_size); + uint32_t Unknown204(); + uint32_t Unknown205(IN uint32_t _0); + uint32_t Unknown206(IN uint8_t * _0, guint _0_size); + uint32_t Unknown207(IN uint8_t _0); + uint32_t Unknown208(IN uint8_t * _0); + uint32_t Unknown209(); + uint32_t Unknown3(OUT uint16_t& _0); + uint32_t Unknown300(); + uint32_t Unknown301(); + uint32_t Unknown302(IN uint8_t * _0, IN uint8_t * _1, IN uint32_t _2, IN uint32_t _3, IN uint8_t * _4, guint _4_size); + uint32_t Unknown303(IN uint8_t * _0, IN uint8_t * _1, IN uint8_t * _2, IN uint32_t _3, IN uint32_t _4, IN uint8_t * _5); + uint32_t Unknown304(); + uint32_t Unknown4(OUT uint8_t * _0); + uint32_t Unknown400(IN uint64_t _0, IN gpid _1); + uint32_t Unknown401(); + uint32_t Unknown5(OUT uint8_t * _0); + }; + class IUserServiceCreator { + public: + IUserServiceCreator(); + uint32_t Unknown0(OUT IUnknown * _0); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::ldn::detail::IMonitorService::Unknown0(OUT uint32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::IMonitorService::Unknown1(OUT uint8_t * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::ldn::detail::IMonitorService::Unknown100() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::IMonitorService::Unknown101() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::IMonitorService::Unknown2(OUT uint32_t& _0, OUT uint32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::IMonitorService::Unknown3(OUT uint16_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::IMonitorService::Unknown4(OUT uint8_t * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::IMonitorService::Unknown5(OUT uint8_t * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::IMonitorServiceCreator::Unknown0(OUT IUnknown * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new IUnknown(resp.move_handles[0]); + return ret; +} +uint32_t nn::ldn::detail::ISystemLocalCommunicationService::Unknown0(OUT uint32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::ISystemLocalCommunicationService::Unknown1(OUT uint8_t * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::ldn::detail::ISystemLocalCommunicationService::Unknown100(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::ldn::detail::ISystemLocalCommunicationService::Unknown101(OUT uint8_t * _0, guint _0_size, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + guint temp5; + auto temp4 = req.getBuffer(0xa, 0, temp5); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +uint32_t nn::ldn::detail::ISystemLocalCommunicationService::Unknown102(IN uint16_t _0, IN uint8_t * _1, OUT uint16_t& _2, OUT uint8_t * _3, guint _3_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x22, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::ldn::detail::ISystemLocalCommunicationService::Unknown103(IN uint16_t _0, IN uint8_t * _1, OUT uint16_t& _2, OUT uint8_t * _3, guint _3_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x22, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::ldn::detail::ISystemLocalCommunicationService::Unknown2(OUT uint32_t& _0, OUT uint32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::ISystemLocalCommunicationService::Unknown200() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::ISystemLocalCommunicationService::Unknown201() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::ISystemLocalCommunicationService::Unknown202(IN uint8_t * _0, IN uint8_t * _1, IN uint8_t * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::ISystemLocalCommunicationService::Unknown203(IN uint8_t * _0, IN uint8_t * _1, IN uint8_t * _2, IN uint8_t * _3, IN uint8_t * _4, guint _4_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(9, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::ldn::detail::ISystemLocalCommunicationService::Unknown204() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::ISystemLocalCommunicationService::Unknown205(IN uint32_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::ISystemLocalCommunicationService::Unknown206(IN uint8_t * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x21, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::ldn::detail::ISystemLocalCommunicationService::Unknown207(IN uint8_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::ISystemLocalCommunicationService::Unknown208(IN uint8_t * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::ISystemLocalCommunicationService::Unknown209() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::ISystemLocalCommunicationService::Unknown3(OUT uint16_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::ISystemLocalCommunicationService::Unknown300() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::ISystemLocalCommunicationService::Unknown301() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::ISystemLocalCommunicationService::Unknown302(IN uint8_t * _0, IN uint8_t * _1, IN uint32_t _2, IN uint32_t _3, IN uint8_t * _4, guint _4_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::ldn::detail::ISystemLocalCommunicationService::Unknown303(IN uint8_t * _0, IN uint8_t * _1, IN uint8_t * _2, IN uint32_t _3, IN uint32_t _4, IN uint8_t * _5) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::ISystemLocalCommunicationService::Unknown304() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::ISystemLocalCommunicationService::Unknown4(OUT uint8_t * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::ISystemLocalCommunicationService::Unknown400(IN uint64_t _0, IN gpid _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::ISystemLocalCommunicationService::Unknown401() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::ISystemLocalCommunicationService::Unknown5(OUT uint8_t * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::ISystemServiceCreator::Unknown0(OUT IUnknown * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new IUnknown(resp.move_handles[0]); + return ret; +} +uint32_t nn::ldn::detail::IUserLocalCommunicationService::Unknown0(OUT uint32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::IUserLocalCommunicationService::Unknown1(OUT uint8_t * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::ldn::detail::IUserLocalCommunicationService::Unknown100(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::ldn::detail::IUserLocalCommunicationService::Unknown101(OUT uint8_t * _0, guint _0_size, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + guint temp5; + auto temp4 = req.getBuffer(0xa, 0, temp5); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +uint32_t nn::ldn::detail::IUserLocalCommunicationService::Unknown102(IN uint16_t _0, IN uint8_t * _1, OUT uint16_t& _2, OUT uint8_t * _3, guint _3_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x22, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::ldn::detail::IUserLocalCommunicationService::Unknown103(IN uint16_t _0, IN uint8_t * _1, OUT uint16_t& _2, OUT uint8_t * _3, guint _3_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x22, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::ldn::detail::IUserLocalCommunicationService::Unknown2(OUT uint32_t& _0, OUT uint32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::IUserLocalCommunicationService::Unknown200() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::IUserLocalCommunicationService::Unknown201() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::IUserLocalCommunicationService::Unknown202(IN uint8_t * _0, IN uint8_t * _1, IN uint8_t * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::IUserLocalCommunicationService::Unknown203(IN uint8_t * _0, IN uint8_t * _1, IN uint8_t * _2, IN uint8_t * _3, IN uint8_t * _4, guint _4_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(9, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::ldn::detail::IUserLocalCommunicationService::Unknown204() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::IUserLocalCommunicationService::Unknown205(IN uint32_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::IUserLocalCommunicationService::Unknown206(IN uint8_t * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x21, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::ldn::detail::IUserLocalCommunicationService::Unknown207(IN uint8_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::IUserLocalCommunicationService::Unknown208(IN uint8_t * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::IUserLocalCommunicationService::Unknown209() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::IUserLocalCommunicationService::Unknown3(OUT uint16_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::IUserLocalCommunicationService::Unknown300() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::IUserLocalCommunicationService::Unknown301() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::IUserLocalCommunicationService::Unknown302(IN uint8_t * _0, IN uint8_t * _1, IN uint32_t _2, IN uint32_t _3, IN uint8_t * _4, guint _4_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::ldn::detail::IUserLocalCommunicationService::Unknown303(IN uint8_t * _0, IN uint8_t * _1, IN uint8_t * _2, IN uint32_t _3, IN uint32_t _4, IN uint8_t * _5) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::IUserLocalCommunicationService::Unknown304() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::IUserLocalCommunicationService::Unknown4(OUT uint8_t * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::IUserLocalCommunicationService::Unknown400(IN uint64_t _0, IN gpid _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::IUserLocalCommunicationService::Unknown401() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::IUserLocalCommunicationService::Unknown5(OUT uint8_t * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ldn::detail::IUserServiceCreator::Unknown0(OUT IUnknown * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new IUnknown(resp.move_handles[0]); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::lm { + class ILogService { + public: + ILogService(); + uint32_t Initialize(IN uint64_t _0, IN gpid _1, OUT nn::lm::ILogger * Log); + }; + class ILogger { + public: + ILogger(); + uint32_t Unknown0(IN uint8_t * _0, guint _0_size); + uint32_t Unknown1(IN uint32_t _0); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::lm::ILogService::Initialize(IN uint64_t _0, IN gpid _1, OUT nn::lm::ILogger * Log) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + Log OMG = new nn::lm::ILogger(resp.move_handles[0]); + return ret; +} +uint32_t nn::lm::ILogger::Unknown0(IN uint8_t * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x21, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::lm::ILogger::Unknown1(IN uint32_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::mii::detail { + class IDatabaseService { + public: + IDatabaseService(); + uint32_t AddOrReplace(IN nn::mii::StoreData _0); + uint32_t BuildDefault(IN int32_t _0, OUT nn::mii::CharInfo& _1); + uint32_t BuildRandom(IN int32_t _0, IN int32_t _1, IN int32_t _2, OUT nn::mii::CharInfo& _3); + uint32_t Delete(IN nn::mii::CreateId _0); + uint32_t DeleteFile(); + uint32_t DestroyFile(); + uint32_t Export(OUT uint8_t * _0, guint _0_size); + uint32_t FindIndex(IN nn::mii::CreateId _0, IN bool _1, OUT int32_t& _2); + uint32_t Format(); + uint32_t Get(IN int32_t _0, OUT int32_t& _1, OUT nn::mii::CharInfoElement * _2, guint _2_size); + uint32_t Get1(IN int32_t _0, OUT int32_t& _1, OUT nn::mii::CharInfo * _2, guint _2_size); + uint32_t Get2(IN int32_t _0, OUT int32_t& _1, OUT nn::mii::StoreDataElement * _2, guint _2_size); + uint32_t Get3(IN int32_t _0, OUT int32_t& _1, OUT nn::mii::StoreData * _2, guint _2_size); + uint32_t GetCount(IN int32_t _0, OUT int32_t& _1); + uint32_t GetIndex(IN nn::mii::CharInfo _0, OUT int32_t& _1); + uint32_t Import(IN uint8_t * _0, guint _0_size); + uint32_t IsBrokenDatabaseWithClearFlag(OUT bool& _0); + uint32_t IsFullDatabase(OUT bool& _0); + uint32_t IsUpdated(IN int32_t _0, OUT bool& _1); + uint32_t Move(IN nn::mii::CreateId _0, IN int32_t _1); + uint32_t UpdateLatest(IN nn::mii::CharInfo _0, IN int32_t _1, OUT nn::mii::CharInfo& _2); + uint32_t UpdateLatest1(IN nn::mii::StoreData _0, IN int32_t _1, OUT nn::mii::StoreData& _2); + }; + class IStaticService { + public: + IStaticService(); + uint32_t GetDatabaseService(IN int32_t _0, OUT nn::mii::detail::IDatabaseService * _1); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::mii::detail::IDatabaseService::AddOrReplace(IN nn::mii::StoreData _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::mii::detail::IDatabaseService::BuildDefault(IN int32_t _0, OUT nn::mii::CharInfo& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::mii::detail::IDatabaseService::BuildRandom(IN int32_t _0, IN int32_t _1, IN int32_t _2, OUT nn::mii::CharInfo& _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::mii::detail::IDatabaseService::Delete(IN nn::mii::CreateId _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::mii::detail::IDatabaseService::DeleteFile() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::mii::detail::IDatabaseService::DestroyFile() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::mii::detail::IDatabaseService::Export(OUT uint8_t * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::mii::detail::IDatabaseService::FindIndex(IN nn::mii::CreateId _0, IN bool _1, OUT int32_t& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::mii::detail::IDatabaseService::Format() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::mii::detail::IDatabaseService::Get(IN int32_t _0, OUT int32_t& _1, OUT nn::mii::CharInfoElement * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::mii::detail::IDatabaseService::Get1(IN int32_t _0, OUT int32_t& _1, OUT nn::mii::CharInfo * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::mii::detail::IDatabaseService::Get2(IN int32_t _0, OUT int32_t& _1, OUT nn::mii::StoreDataElement * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::mii::detail::IDatabaseService::Get3(IN int32_t _0, OUT int32_t& _1, OUT nn::mii::StoreData * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::mii::detail::IDatabaseService::GetCount(IN int32_t _0, OUT int32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::mii::detail::IDatabaseService::GetIndex(IN nn::mii::CharInfo _0, OUT int32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::mii::detail::IDatabaseService::Import(IN uint8_t * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::mii::detail::IDatabaseService::IsBrokenDatabaseWithClearFlag(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::mii::detail::IDatabaseService::IsFullDatabase(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::mii::detail::IDatabaseService::IsUpdated(IN int32_t _0, OUT bool& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::mii::detail::IDatabaseService::Move(IN nn::mii::CreateId _0, IN int32_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::mii::detail::IDatabaseService::UpdateLatest(IN nn::mii::CharInfo _0, IN int32_t _1, OUT nn::mii::CharInfo& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::mii::detail::IDatabaseService::UpdateLatest1(IN nn::mii::StoreData _0, IN int32_t _1, OUT nn::mii::StoreData& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::mii::detail::IStaticService::GetDatabaseService(IN int32_t _0, OUT nn::mii::detail::IDatabaseService * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new nn::mii::detail::IDatabaseService(resp.move_handles[0]); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::mmnv { + class IRequest { + public: + IRequest(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + uint32_t Unknown5(); + uint32_t Unknown6(); + uint32_t Unknown7(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::mmnv::IRequest::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::mmnv::IRequest::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::mmnv::IRequest::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::mmnv::IRequest::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::mmnv::IRequest::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::mmnv::IRequest::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::mmnv::IRequest::Unknown6() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::mmnv::IRequest::Unknown7() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::ncm::detail { + class INcmInterface { + public: + INcmInterface(); + uint32_t Unknown11(OUT uint64_t& _0); + uint32_t Unknown2(OUT uint64_t& _0); + uint32_t Unknown3(OUT uint64_t& _0); + uint32_t Unknown4(OUT nn::ncm::detail::INcmInterface4Unknown * _0); + uint32_t Unknown5(OUT nn::ncm::detail::INcmInterface5Unknown * _0); + uint32_t Unknown9(OUT uint64_t& _0); + }; + class INcmInterface4Unknown { + public: + INcmInterface4Unknown(); + uint32_t Unknown10(); + uint32_t Unknown13(OUT uint64_t& _0); + }; + class INcmInterface5Unknown { + public: + INcmInterface5Unknown(); + uint32_t Unknown15(); + uint32_t Unknown5(OUT uint64_t& _0); + uint32_t Unknown7(OUT uint64_t& _0); + uint32_t Unknown8(); + }; + class LocationResolverInterface { + public: + LocationResolverInterface(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::ncm::detail::INcmInterface::Unknown11(OUT uint64_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ncm::detail::INcmInterface::Unknown2(OUT uint64_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ncm::detail::INcmInterface::Unknown3(OUT uint64_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ncm::detail::INcmInterface::Unknown4(OUT nn::ncm::detail::INcmInterface4Unknown * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::ncm::detail::INcmInterface4Unknown(resp.move_handles[0]); + return ret; +} +uint32_t nn::ncm::detail::INcmInterface::Unknown5(OUT nn::ncm::detail::INcmInterface5Unknown * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::ncm::detail::INcmInterface5Unknown(resp.move_handles[0]); + return ret; +} +uint32_t nn::ncm::detail::INcmInterface::Unknown9(OUT uint64_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ncm::detail::INcmInterface4Unknown::Unknown10() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ncm::detail::INcmInterface4Unknown::Unknown13(OUT uint64_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ncm::detail::INcmInterface5Unknown::Unknown15() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ncm::detail::INcmInterface5Unknown::Unknown5(OUT uint64_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ncm::detail::INcmInterface5Unknown::Unknown7(OUT uint64_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ncm::detail::INcmInterface5Unknown::Unknown8() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::news::detail::ipc { + class INewlyArrivedEventHolder { + public: + INewlyArrivedEventHolder(); + uint32_t Unknown0(); + }; + class INewsDataService { + public: + INewsDataService(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + uint32_t Unknown3(); + }; + class INewsDatabaseService { + public: + INewsDatabaseService(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + uint32_t Unknown5(); + }; + class INewsService { + public: + INewsService(); + uint32_t Unknown10100(); + uint32_t Unknown20100(); + uint32_t Unknown30100(); + uint32_t Unknown30101(); + uint32_t Unknown30200(); + uint32_t Unknown30400(); + uint32_t Unknown40100(); + uint32_t Unknown40101(); + uint32_t Unknown90100(); + }; + class IOverwriteEventHolder { + public: + IOverwriteEventHolder(); + uint32_t Unknown0(); + }; + class IServiceCreator { + public: + IServiceCreator(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::news::detail::ipc::INewlyArrivedEventHolder::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::news::detail::ipc::INewsDataService::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::news::detail::ipc::INewsDataService::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::news::detail::ipc::INewsDataService::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::news::detail::ipc::INewsDataService::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::news::detail::ipc::INewsDatabaseService::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::news::detail::ipc::INewsDatabaseService::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::news::detail::ipc::INewsDatabaseService::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::news::detail::ipc::INewsDatabaseService::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::news::detail::ipc::INewsDatabaseService::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::news::detail::ipc::INewsDatabaseService::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::news::detail::ipc::INewsService::Unknown10100() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::news::detail::ipc::INewsService::Unknown20100() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::news::detail::ipc::INewsService::Unknown30100() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::news::detail::ipc::INewsService::Unknown30101() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::news::detail::ipc::INewsService::Unknown30200() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::news::detail::ipc::INewsService::Unknown30400() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::news::detail::ipc::INewsService::Unknown40100() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::news::detail::ipc::INewsService::Unknown40101() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::news::detail::ipc::INewsService::Unknown90100() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::news::detail::ipc::IOverwriteEventHolder::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::news::detail::ipc::IServiceCreator::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::news::detail::ipc::IServiceCreator::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::news::detail::ipc::IServiceCreator::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::news::detail::ipc::IServiceCreator::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::news::detail::ipc::IServiceCreator::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::nfc::am::detail { + class IAm { + public: + IAm(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + }; + class IAmManager { + public: + IAmManager(); + uint32_t Unknown0(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::nfc::am::detail::IAm::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfc::am::detail::IAm::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfc::am::detail::IAm::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfc::am::detail::IAmManager::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::nfc::detail { + class ISystem { + public: + ISystem(); + uint32_t Unknown0(IN uint64_t _0, IN uint64_t _1, IN gpid _2, IN uint8_t * _3, guint _3_size); + uint32_t Unknown1(); + uint32_t Unknown100(IN uint8_t _0); + uint32_t Unknown2(OUT uint32_t& _0); + uint32_t Unknown3(OUT uint8_t& _0); + }; + class ISystemManager { + public: + ISystemManager(); + uint32_t Unknown0(OUT IUnknown * _0); + }; + class IUser { + public: + IUser(); + uint32_t Unknown0(IN uint64_t _0, IN uint64_t _1, IN gpid _2, IN uint8_t * _3, guint _3_size); + uint32_t Unknown1(); + uint32_t Unknown2(OUT uint32_t& _0); + uint32_t Unknown3(OUT uint8_t& _0); + }; + class IUserManager { + public: + IUserManager(); + uint32_t Unknown0(OUT IUnknown * _0); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::nfc::detail::ISystem::Unknown0(IN uint64_t _0, IN uint64_t _1, IN gpid _2, IN uint8_t * _3, guint _3_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::nfc::detail::ISystem::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfc::detail::ISystem::Unknown100(IN uint8_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfc::detail::ISystem::Unknown2(OUT uint32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfc::detail::ISystem::Unknown3(OUT uint8_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfc::detail::ISystemManager::Unknown0(OUT IUnknown * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new IUnknown(resp.move_handles[0]); + return ret; +} +uint32_t nn::nfc::detail::IUser::Unknown0(IN uint64_t _0, IN uint64_t _1, IN gpid _2, IN uint8_t * _3, guint _3_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::nfc::detail::IUser::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfc::detail::IUser::Unknown2(OUT uint32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfc::detail::IUser::Unknown3(OUT uint8_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfc::detail::IUserManager::Unknown0(OUT IUnknown * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new IUnknown(resp.move_handles[0]); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::nfc::mifare::detail { + class IUser { + public: + IUser(); + uint32_t Unknown0(IN uint64_t _0, IN uint64_t _1, IN gpid _2, IN uint8_t * _3, guint _3_size); + uint32_t Unknown1(); + uint32_t Unknown10(OUT uint32_t& _0); + uint32_t Unknown11(IN uint64_t _0, OUT uint32_t& _1); + uint32_t Unknown12(IN uint64_t _0, OUT uint32_t& _1); + uint32_t Unknown13(OUT KObject * _0); + uint32_t Unknown2(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown3(IN uint64_t _0); + uint32_t Unknown4(IN uint64_t _0); + uint32_t Unknown5(IN uint64_t _0, IN uint8_t * _1, guint _1_size, OUT uint8_t * _2, guint _2_size); + uint32_t Unknown6(IN uint64_t _0, IN uint8_t * _1, guint _1_size); + uint32_t Unknown7(IN uint64_t _0, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown8(IN uint64_t _0, OUT KObject * _1); + uint32_t Unknown9(IN uint64_t _0, OUT KObject * _1); + }; + class IUserManager { + public: + IUserManager(); + uint32_t Unknown0(OUT IUnknown * _0); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::nfc::mifare::detail::IUser::Unknown0(IN uint64_t _0, IN uint64_t _1, IN gpid _2, IN uint8_t * _3, guint _3_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::nfc::mifare::detail::IUser::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfc::mifare::detail::IUser::Unknown10(OUT uint32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfc::mifare::detail::IUser::Unknown11(IN uint64_t _0, OUT uint32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfc::mifare::detail::IUser::Unknown12(IN uint64_t _0, OUT uint32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfc::mifare::detail::IUser::Unknown13(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::nfc::mifare::detail::IUser::Unknown2(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0xa, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nfc::mifare::detail::IUser::Unknown3(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfc::mifare::detail::IUser::Unknown4(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfc::mifare::detail::IUser::Unknown5(IN uint64_t _0, IN uint8_t * _1, guint _1_size, OUT uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(6, 0, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +uint32_t nn::nfc::mifare::detail::IUser::Unknown6(IN uint64_t _0, IN uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::nfc::mifare::detail::IUser::Unknown7(IN uint64_t _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nfc::mifare::detail::IUser::Unknown8(IN uint64_t _0, OUT KObject * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::nfc::mifare::detail::IUser::Unknown9(IN uint64_t _0, OUT KObject * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::nfc::mifare::detail::IUserManager::Unknown0(OUT IUnknown * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new IUnknown(resp.move_handles[0]); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::nfp::detail { + class IDebug { + public: + IDebug(); + uint32_t Unknown0(IN uint64_t _0, IN uint64_t _1, IN gpid _2, IN uint8_t * _3, guint _3_size); + uint32_t Unknown1(); + uint32_t Unknown10(IN uint64_t _0); + uint32_t Unknown100(IN uint64_t _0); + uint32_t Unknown101(IN uint64_t _0, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown102(IN uint64_t _0, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown103(IN uint64_t _0, IN uint8_t * _1, guint _1_size); + uint32_t Unknown104(IN uint64_t _0); + uint32_t Unknown105(IN uint64_t _0); + uint32_t Unknown106(IN uint64_t _0, OUT uint8_t& _1); + uint32_t Unknown11(IN uint64_t _0); + uint32_t Unknown12(IN uint64_t _0, IN uint32_t _1, IN uint8_t * _2, guint _2_size); + uint32_t Unknown13(IN uint64_t _0, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown14(IN uint64_t _0, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown15(IN uint64_t _0, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown16(IN uint64_t _0, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown17(IN uint64_t _0, OUT KObject * _1); + uint32_t Unknown18(IN uint64_t _0, OUT KObject * _1); + uint32_t Unknown19(OUT uint32_t& _0); + uint32_t Unknown2(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown20(IN uint64_t _0, OUT uint32_t& _1); + uint32_t Unknown200(IN uint64_t _0, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown201(IN uint64_t _0, IN uint8_t * _1, guint _1_size); + uint32_t Unknown202(IN uint64_t _0); + uint32_t Unknown203(IN uint64_t _0, IN uint32_t _1); + uint32_t Unknown204(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown205(IN uint8_t * _0, guint _0_size); + uint32_t Unknown206(IN uint64_t _0, IN uint32_t _1, IN uint8_t * _2, guint _2_size); + uint32_t Unknown21(IN uint64_t _0, OUT uint32_t& _1); + uint32_t Unknown22(IN uint64_t _0, OUT uint32_t& _1); + uint32_t Unknown23(OUT KObject * _0); + uint32_t Unknown24(IN uint64_t _0, IN uint32_t _1, IN uint8_t * _2, guint _2_size); + uint32_t Unknown3(IN uint64_t _0); + uint32_t Unknown300(IN uint64_t _0, IN uint64_t _1, IN gpid _2, IN uint8_t * _3, guint _3_size); + uint32_t Unknown301(); + uint32_t Unknown302(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown303(IN uint64_t _0, IN uint32_t _1); + uint32_t Unknown304(IN uint64_t _0); + uint32_t Unknown305(IN uint64_t _0, IN uint64_t _1, IN uint8_t * _2, guint _2_size, OUT uint32_t& _3, OUT uint8_t * _4, guint _4_size); + uint32_t Unknown306(IN uint64_t _0, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown307(IN uint64_t _0, OUT KObject * _1); + uint32_t Unknown308(IN uint64_t _0, OUT KObject * _1); + uint32_t Unknown309(OUT uint32_t& _0); + uint32_t Unknown310(IN uint64_t _0, OUT uint32_t& _1); + uint32_t Unknown311(IN uint64_t _0, OUT uint32_t& _1); + uint32_t Unknown312(IN uint64_t _0); + uint32_t Unknown313(IN uint64_t _0); + uint32_t Unknown314(OUT KObject * _0); + uint32_t Unknown4(IN uint64_t _0); + uint32_t Unknown5(IN uint64_t _0, IN uint32_t _1, IN uint32_t _2); + uint32_t Unknown6(IN uint64_t _0); + uint32_t Unknown7(IN uint64_t _0, IN uint32_t _1); + uint32_t Unknown8(IN uint64_t _0, OUT uint32_t& _1, OUT uint8_t * _2, guint _2_size); + uint32_t Unknown9(IN uint64_t _0, IN uint8_t * _1, guint _1_size); + }; + class IDebugManager { + public: + IDebugManager(); + uint32_t Unknown0(OUT IUnknown * _0); + }; + class ISystem { + public: + ISystem(); + uint32_t Unknown0(IN uint64_t _0, IN uint64_t _1, IN gpid _2, IN uint8_t * _3, guint _3_size); + uint32_t Unknown1(); + uint32_t Unknown10(IN uint64_t _0); + uint32_t Unknown100(IN uint64_t _0); + uint32_t Unknown101(IN uint64_t _0, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown102(IN uint64_t _0, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown103(IN uint64_t _0, IN uint8_t * _1, guint _1_size); + uint32_t Unknown104(IN uint64_t _0); + uint32_t Unknown105(IN uint64_t _0); + uint32_t Unknown106(IN uint64_t _0, OUT uint8_t& _1); + uint32_t Unknown11(IN uint64_t _0); + uint32_t Unknown13(IN uint64_t _0, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown14(IN uint64_t _0, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown15(IN uint64_t _0, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown16(IN uint64_t _0, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown17(IN uint64_t _0, OUT KObject * _1); + uint32_t Unknown18(IN uint64_t _0, OUT KObject * _1); + uint32_t Unknown19(OUT uint32_t& _0); + uint32_t Unknown2(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown20(IN uint64_t _0, OUT uint32_t& _1); + uint32_t Unknown21(IN uint64_t _0, OUT uint32_t& _1); + uint32_t Unknown23(OUT KObject * _0); + uint32_t Unknown3(IN uint64_t _0); + uint32_t Unknown4(IN uint64_t _0); + uint32_t Unknown5(IN uint64_t _0, IN uint32_t _1, IN uint32_t _2); + uint32_t Unknown6(IN uint64_t _0); + }; + class ISystemManager { + public: + ISystemManager(); + uint32_t Unknown0(OUT IUnknown * _0); + }; + class IUser { + public: + IUser(); + uint32_t Unknown0(IN uint64_t _0, IN uint64_t _1, IN gpid _2, IN uint8_t * _3, guint _3_size); + uint32_t Unknown1(); + uint32_t Unknown10(IN uint64_t _0); + uint32_t Unknown11(IN uint64_t _0); + uint32_t Unknown12(IN uint64_t _0, IN uint32_t _1, IN uint8_t * _2, guint _2_size); + uint32_t Unknown13(IN uint64_t _0, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown14(IN uint64_t _0, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown15(IN uint64_t _0, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown16(IN uint64_t _0, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown17(IN uint64_t _0, OUT KObject * _1); + uint32_t Unknown18(IN uint64_t _0, OUT KObject * _1); + uint32_t Unknown19(OUT uint32_t& _0); + uint32_t Unknown2(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown20(IN uint64_t _0, OUT uint32_t& _1); + uint32_t Unknown21(IN uint64_t _0, OUT uint32_t& _1); + uint32_t Unknown22(IN uint64_t _0, OUT uint32_t& _1); + uint32_t Unknown23(OUT KObject * _0); + uint32_t Unknown24(IN uint64_t _0, IN uint32_t _1, IN uint8_t * _2, guint _2_size); + uint32_t Unknown3(IN uint64_t _0); + uint32_t Unknown4(IN uint64_t _0); + uint32_t Unknown5(IN uint64_t _0, IN uint32_t _1, IN uint32_t _2); + uint32_t Unknown6(IN uint64_t _0); + uint32_t Unknown7(IN uint64_t _0, IN uint32_t _1); + uint32_t Unknown8(IN uint64_t _0, OUT uint32_t& _1, OUT uint8_t * _2, guint _2_size); + uint32_t Unknown9(IN uint64_t _0, IN uint8_t * _1, guint _1_size); + }; + class IUserManager { + public: + IUserManager(); + uint32_t Unknown0(OUT IUnknown * _0); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::nfp::detail::IDebug::Unknown0(IN uint64_t _0, IN uint64_t _1, IN gpid _2, IN uint8_t * _3, guint _3_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown10(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown100(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown101(IN uint64_t _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown102(IN uint64_t _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown103(IN uint64_t _0, IN uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown104(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown105(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown106(IN uint64_t _0, OUT uint8_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown11(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown12(IN uint64_t _0, IN uint32_t _1, IN uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown13(IN uint64_t _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown14(IN uint64_t _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown15(IN uint64_t _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown16(IN uint64_t _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown17(IN uint64_t _0, OUT KObject * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown18(IN uint64_t _0, OUT KObject * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown19(OUT uint32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown2(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0xa, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown20(IN uint64_t _0, OUT uint32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown200(IN uint64_t _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown201(IN uint64_t _0, IN uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown202(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown203(IN uint64_t _0, IN uint32_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown204(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown205(IN uint8_t * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown206(IN uint64_t _0, IN uint32_t _1, IN uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown21(IN uint64_t _0, OUT uint32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown22(IN uint64_t _0, OUT uint32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown23(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown24(IN uint64_t _0, IN uint32_t _1, IN uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown3(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown300(IN uint64_t _0, IN uint64_t _1, IN gpid _2, IN uint8_t * _3, guint _3_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown301() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown302(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0xa, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown303(IN uint64_t _0, IN uint32_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown304(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown305(IN uint64_t _0, IN uint64_t _1, IN uint8_t * _2, guint _2_size, OUT uint32_t& _3, OUT uint8_t * _4, guint _4_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(6, 0, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown306(IN uint64_t _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown307(IN uint64_t _0, OUT KObject * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown308(IN uint64_t _0, OUT KObject * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown309(OUT uint32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown310(IN uint64_t _0, OUT uint32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown311(IN uint64_t _0, OUT uint32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown312(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown313(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown314(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown4(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown5(IN uint64_t _0, IN uint32_t _1, IN uint32_t _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown6(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown7(IN uint64_t _0, IN uint32_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown8(IN uint64_t _0, OUT uint32_t& _1, OUT uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nfp::detail::IDebug::Unknown9(IN uint64_t _0, IN uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::nfp::detail::IDebugManager::Unknown0(OUT IUnknown * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new IUnknown(resp.move_handles[0]); + return ret; +} +uint32_t nn::nfp::detail::ISystem::Unknown0(IN uint64_t _0, IN uint64_t _1, IN gpid _2, IN uint8_t * _3, guint _3_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::nfp::detail::ISystem::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::ISystem::Unknown10(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::ISystem::Unknown100(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::ISystem::Unknown101(IN uint64_t _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nfp::detail::ISystem::Unknown102(IN uint64_t _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nfp::detail::ISystem::Unknown103(IN uint64_t _0, IN uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::nfp::detail::ISystem::Unknown104(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::ISystem::Unknown105(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::ISystem::Unknown106(IN uint64_t _0, OUT uint8_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::ISystem::Unknown11(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::ISystem::Unknown13(IN uint64_t _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nfp::detail::ISystem::Unknown14(IN uint64_t _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nfp::detail::ISystem::Unknown15(IN uint64_t _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nfp::detail::ISystem::Unknown16(IN uint64_t _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nfp::detail::ISystem::Unknown17(IN uint64_t _0, OUT KObject * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::nfp::detail::ISystem::Unknown18(IN uint64_t _0, OUT KObject * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::nfp::detail::ISystem::Unknown19(OUT uint32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::ISystem::Unknown2(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0xa, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nfp::detail::ISystem::Unknown20(IN uint64_t _0, OUT uint32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::ISystem::Unknown21(IN uint64_t _0, OUT uint32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::ISystem::Unknown23(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::nfp::detail::ISystem::Unknown3(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::ISystem::Unknown4(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::ISystem::Unknown5(IN uint64_t _0, IN uint32_t _1, IN uint32_t _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::ISystem::Unknown6(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::ISystemManager::Unknown0(OUT IUnknown * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new IUnknown(resp.move_handles[0]); + return ret; +} +uint32_t nn::nfp::detail::IUser::Unknown0(IN uint64_t _0, IN uint64_t _1, IN gpid _2, IN uint8_t * _3, guint _3_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::nfp::detail::IUser::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::IUser::Unknown10(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::IUser::Unknown11(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::IUser::Unknown12(IN uint64_t _0, IN uint32_t _1, IN uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::nfp::detail::IUser::Unknown13(IN uint64_t _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nfp::detail::IUser::Unknown14(IN uint64_t _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nfp::detail::IUser::Unknown15(IN uint64_t _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nfp::detail::IUser::Unknown16(IN uint64_t _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nfp::detail::IUser::Unknown17(IN uint64_t _0, OUT KObject * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::nfp::detail::IUser::Unknown18(IN uint64_t _0, OUT KObject * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::nfp::detail::IUser::Unknown19(OUT uint32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::IUser::Unknown2(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0xa, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nfp::detail::IUser::Unknown20(IN uint64_t _0, OUT uint32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::IUser::Unknown21(IN uint64_t _0, OUT uint32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::IUser::Unknown22(IN uint64_t _0, OUT uint32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::IUser::Unknown23(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::nfp::detail::IUser::Unknown24(IN uint64_t _0, IN uint32_t _1, IN uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::nfp::detail::IUser::Unknown3(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::IUser::Unknown4(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::IUser::Unknown5(IN uint64_t _0, IN uint32_t _1, IN uint32_t _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::IUser::Unknown6(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::IUser::Unknown7(IN uint64_t _0, IN uint32_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nfp::detail::IUser::Unknown8(IN uint64_t _0, OUT uint32_t& _1, OUT uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nfp::detail::IUser::Unknown9(IN uint64_t _0, IN uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::nfp::detail::IUserManager::Unknown0(OUT IUnknown * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new IUnknown(resp.move_handles[0]); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::nifm::detail { + class IGeneralService { + public: + IGeneralService(); + uint32_t ConfirmSystemAvailability(); + uint32_t CreateRequest(IN int32_t _0, OUT nn::nifm::detail::IRequest * _1); + uint32_t CreateScanRequest(OUT nn::nifm::detail::IScanRequest * _0); + uint32_t CreateTemporaryNetworkProfile(IN nn::nifm::detail::sf::NetworkProfileData * _0, guint _0_size, OUT nn::util::Uuid& _1, OUT nn::nifm::detail::INetworkProfile * _2); + uint32_t EnumerateNetworkInterfaces(IN uint32_t _0, OUT int32_t& _1, OUT nn::nifm::detail::sf::NetworkInterfaceInfo * _2, guint _2_size); + uint32_t EnumerateNetworkProfiles(IN uint8_t _0, OUT int32_t& _1, OUT nn::nifm::detail::sf::NetworkProfileBasicInfo * _2, guint _2_size); + uint32_t GetClientId(OUT nn::nifm::ClientId * _0, guint _0_size); + uint32_t GetCurrentAccessPoint(OUT nn::nifm::detail::sf::AccessPointData * _0, guint _0_size); + uint32_t GetCurrentIpAddress(OUT nn::nifm::IpV4Address& _0); + uint32_t GetCurrentIpConfigInfo(OUT nn::nifm::IpAddressSetting& _0, OUT nn::nifm::DnsSetting& _1); + uint32_t GetCurrentNetworkProfile(OUT nn::nifm::detail::sf::NetworkProfileData * _0, guint _0_size); + uint32_t GetDefaultIpSetting(OUT nn::nifm::IpSettingData * _0, guint _0_size); + uint32_t GetInternetConnectionStatus(OUT nn::nifm::detail::sf::InternetConnectionStatus& _0); + uint32_t GetNetworkProfile(IN nn::util::Uuid _0, OUT nn::nifm::detail::sf::NetworkProfileData * _1, guint _1_size); + uint32_t GetScanData(OUT int32_t& _0, OUT nn::nifm::detail::sf::AccessPointData * _1, guint _1_size); + uint32_t GetSsidListVersion(OUT nn::nifm::SsidListVersion& _0); + uint32_t GetTelemetorySystemEventReadableHandle(OUT KObject * _0); + uint32_t GetTelemetryInfo(OUT nn::nifm::TelemetryInfo * _0, guint _0_size); + uint32_t IsAnyForegroundRequestAccepted(OUT bool& _0); + uint32_t IsAnyInternetRequestAccepted(IN nn::nifm::ClientId * _0, guint _0_size, OUT bool& _1); + uint32_t IsEthernetCommunicationEnabled(OUT bool& _0); + uint32_t IsWirelessCommunicationEnabled(OUT bool& _0); + uint32_t PutToSleep(); + uint32_t RemoveNetworkProfile(IN nn::util::Uuid _0); + uint32_t SetDefaultIpSetting(IN nn::nifm::IpSettingData * _0, guint _0_size); + uint32_t SetEthernetCommunicationEnabled(IN bool _0); + uint32_t SetEthernetCommunicationEnabledForTest(IN bool _0); + uint32_t SetExclusiveClient(IN nn::nifm::ClientId * _0, guint _0_size); + uint32_t SetNetworkProfile(IN nn::nifm::detail::sf::NetworkProfileData * _0, guint _0_size, OUT nn::util::Uuid& _1); + uint32_t SetWirelessCommunicationEnabled(IN bool _0); + uint32_t SetWirelessCommunicationEnabledForTest(IN bool _0); + uint32_t WakeUp(); + }; + class INetworkProfile { + public: + INetworkProfile(); + uint32_t Persist(OUT nn::util::Uuid& _0); + uint32_t PersistOld(IN nn::util::Uuid _0, OUT nn::util::Uuid& _1); + uint32_t Update(IN nn::nifm::detail::sf::NetworkProfileData * _0, guint _0_size, OUT nn::util::Uuid& _1); + }; + class IRequest { + public: + IRequest(); + uint32_t Cancel(); + uint32_t GetAdditionalInfo(OUT uint32_t& _0, OUT nn::nifm::AdditionalInfo * _1, guint _1_size); + uint32_t GetAppletInfo(IN uint32_t _0, OUT uint32_t& _1, OUT uint32_t& _2, OUT uint32_t& _3, OUT uint8_t * _4, guint _4_size); + uint32_t GetRequestState(OUT int32_t& _0); + uint32_t GetRequirement(OUT nn::nifm::Requirement& _0); + uint32_t GetResult(); + uint32_t GetRevision(OUT uint32_t& _0); + uint32_t GetSystemEventReadableHandles(OUT KObject * _0, OUT KObject * _1); + uint32_t RegisterSocketDescriptor(IN int32_t _0); + uint32_t SetConnectionConfirmationOption(IN int8_t _0); + uint32_t SetGreedy(IN bool _0); + uint32_t SetInstant(IN bool _0); + uint32_t SetKeptInSleep(IN bool _0); + uint32_t SetNetworkProfileId(IN nn::util::Uuid _0); + uint32_t SetPersistent(IN bool _0); + uint32_t SetPriority(IN uint8_t _0); + uint32_t SetRawPriority(IN uint8_t _0); + uint32_t SetRejectable(IN bool _0); + uint32_t SetRequirement(IN nn::nifm::Requirement _0); + uint32_t SetRequirementByRevision(IN uint32_t _0); + uint32_t SetRequirementPreset(IN int32_t _0); + uint32_t SetSharable(IN bool _0); + uint32_t SetSustainable(IN bool _0, IN uint8_t _1); + uint32_t Submit(); + uint32_t UnregisterSocketDescriptor(IN int32_t _0); + }; + class IScanRequest { + public: + IScanRequest(); + uint32_t GetResult(); + uint32_t GetSystemEventReadableHandle(OUT KObject * _0); + uint32_t IsProcessing(OUT bool& _0); + uint32_t Submit(); + }; + class IStaticService { + public: + IStaticService(); + uint32_t CreateGeneralService(IN uint64_t _0, IN gpid _1, OUT nn::nifm::detail::IGeneralService * _2); + uint32_t CreateGeneralServiceOld(OUT nn::nifm::detail::IGeneralService * _0); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::nifm::detail::IGeneralService::ConfirmSystemAvailability() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nifm::detail::IGeneralService::CreateRequest(IN int32_t _0, OUT nn::nifm::detail::IRequest * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new nn::nifm::detail::IRequest(resp.move_handles[0]); + return ret; +} +uint32_t nn::nifm::detail::IGeneralService::CreateScanRequest(OUT nn::nifm::detail::IScanRequest * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::nifm::detail::IScanRequest(resp.move_handles[0]); + return ret; +} +uint32_t nn::nifm::detail::IGeneralService::CreateTemporaryNetworkProfile(IN nn::nifm::detail::sf::NetworkProfileData * _0, guint _0_size, OUT nn::util::Uuid& _1, OUT nn::nifm::detail::INetworkProfile * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + _2 OMG = new nn::nifm::detail::INetworkProfile(resp.move_handles[0]); + return ret; +} +uint32_t nn::nifm::detail::IGeneralService::EnumerateNetworkInterfaces(IN uint32_t _0, OUT int32_t& _1, OUT nn::nifm::detail::sf::NetworkInterfaceInfo * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0xa, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nifm::detail::IGeneralService::EnumerateNetworkProfiles(IN uint8_t _0, OUT int32_t& _1, OUT nn::nifm::detail::sf::NetworkProfileBasicInfo * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nifm::detail::IGeneralService::GetClientId(OUT nn::nifm::ClientId * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nifm::detail::IGeneralService::GetCurrentAccessPoint(OUT nn::nifm::detail::sf::AccessPointData * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nifm::detail::IGeneralService::GetCurrentIpAddress(OUT nn::nifm::IpV4Address& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nifm::detail::IGeneralService::GetCurrentIpConfigInfo(OUT nn::nifm::IpAddressSetting& _0, OUT nn::nifm::DnsSetting& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto temp2 = resp.getDataPointer(0x15); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nifm::detail::IGeneralService::GetCurrentNetworkProfile(OUT nn::nifm::detail::sf::NetworkProfileData * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nifm::detail::IGeneralService::GetDefaultIpSetting(OUT nn::nifm::IpSettingData * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nifm::detail::IGeneralService::GetInternetConnectionStatus(OUT nn::nifm::detail::sf::InternetConnectionStatus& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(9); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nifm::detail::IGeneralService::GetNetworkProfile(IN nn::util::Uuid _0, OUT nn::nifm::detail::sf::NetworkProfileData * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nifm::detail::IGeneralService::GetScanData(OUT int32_t& _0, OUT nn::nifm::detail::sf::AccessPointData * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nifm::detail::IGeneralService::GetSsidListVersion(OUT nn::nifm::SsidListVersion& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nifm::detail::IGeneralService::GetTelemetorySystemEventReadableHandle(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::nifm::detail::IGeneralService::GetTelemetryInfo(OUT nn::nifm::TelemetryInfo * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x16, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nifm::detail::IGeneralService::IsAnyForegroundRequestAccepted(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nifm::detail::IGeneralService::IsAnyInternetRequestAccepted(IN nn::nifm::ClientId * _0, guint _0_size, OUT bool& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::nifm::detail::IGeneralService::IsEthernetCommunicationEnabled(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nifm::detail::IGeneralService::IsWirelessCommunicationEnabled(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nifm::detail::IGeneralService::PutToSleep() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nifm::detail::IGeneralService::RemoveNetworkProfile(IN nn::util::Uuid _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nifm::detail::IGeneralService::SetDefaultIpSetting(IN nn::nifm::IpSettingData * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::nifm::detail::IGeneralService::SetEthernetCommunicationEnabled(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nifm::detail::IGeneralService::SetEthernetCommunicationEnabledForTest(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nifm::detail::IGeneralService::SetExclusiveClient(IN nn::nifm::ClientId * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::nifm::detail::IGeneralService::SetNetworkProfile(IN nn::nifm::detail::sf::NetworkProfileData * _0, guint _0_size, OUT nn::util::Uuid& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::nifm::detail::IGeneralService::SetWirelessCommunicationEnabled(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nifm::detail::IGeneralService::SetWirelessCommunicationEnabledForTest(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nifm::detail::IGeneralService::WakeUp() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nifm::detail::INetworkProfile::Persist(OUT nn::util::Uuid& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nifm::detail::INetworkProfile::PersistOld(IN nn::util::Uuid _0, OUT nn::util::Uuid& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nifm::detail::INetworkProfile::Update(IN nn::nifm::detail::sf::NetworkProfileData * _0, guint _0_size, OUT nn::util::Uuid& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::nifm::detail::IRequest::Cancel() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nifm::detail::IRequest::GetAdditionalInfo(OUT uint32_t& _0, OUT nn::nifm::AdditionalInfo * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x16, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nifm::detail::IRequest::GetAppletInfo(IN uint32_t _0, OUT uint32_t& _1, OUT uint32_t& _2, OUT uint32_t& _3, OUT uint8_t * _4, guint _4_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nifm::detail::IRequest::GetRequestState(OUT int32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nifm::detail::IRequest::GetRequirement(OUT nn::nifm::Requirement& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nifm::detail::IRequest::GetResult() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nifm::detail::IRequest::GetRevision(OUT uint32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nifm::detail::IRequest::GetSystemEventReadableHandles(OUT KObject * _0, OUT KObject * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + shared_ptr temp2; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + if(temp2 != nullptr) + resp.copy(1, ctu->newHandle(temp2)); + return ret; +} +uint32_t nn::nifm::detail::IRequest::RegisterSocketDescriptor(IN int32_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nifm::detail::IRequest::SetConnectionConfirmationOption(IN int8_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nifm::detail::IRequest::SetGreedy(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nifm::detail::IRequest::SetInstant(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nifm::detail::IRequest::SetKeptInSleep(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nifm::detail::IRequest::SetNetworkProfileId(IN nn::util::Uuid _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nifm::detail::IRequest::SetPersistent(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nifm::detail::IRequest::SetPriority(IN uint8_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nifm::detail::IRequest::SetRawPriority(IN uint8_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nifm::detail::IRequest::SetRejectable(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nifm::detail::IRequest::SetRequirement(IN nn::nifm::Requirement _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nifm::detail::IRequest::SetRequirementByRevision(IN uint32_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nifm::detail::IRequest::SetRequirementPreset(IN int32_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nifm::detail::IRequest::SetSharable(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nifm::detail::IRequest::SetSustainable(IN bool _0, IN uint8_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nifm::detail::IRequest::Submit() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nifm::detail::IRequest::UnregisterSocketDescriptor(IN int32_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nifm::detail::IScanRequest::GetResult() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nifm::detail::IScanRequest::GetSystemEventReadableHandle(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::nifm::detail::IScanRequest::IsProcessing(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nifm::detail::IScanRequest::Submit() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nifm::detail::IStaticService::CreateGeneralService(IN uint64_t _0, IN gpid _1, OUT nn::nifm::detail::IGeneralService * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _2 OMG = new nn::nifm::detail::IGeneralService(resp.move_handles[0]); + return ret; +} +uint32_t nn::nifm::detail::IStaticService::CreateGeneralServiceOld(OUT nn::nifm::detail::IGeneralService * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::nifm::detail::IGeneralService(resp.move_handles[0]); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::nim::detail { + class IAsyncData { + public: + IAsyncData(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + }; + class IAsyncProgressResult { + public: + IAsyncProgressResult(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + }; + class IAsyncResult { + public: + IAsyncResult(); + uint32_t Unknown0(); + uint32_t Unknown1(); + }; + class IAsyncValue { + public: + IAsyncValue(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + }; + class INetworkInstallManager { + public: + INetworkInstallManager(); + uint32_t Unknown2(IN uint8_t * _0, guint _0_size, OUT uint64_t& _1, OUT uint64_t& _2); + uint32_t Unknown40(IN uint8_t * _0, guint _0_size, OUT uint64_t& _1, OUT uint64_t& _2); + uint32_t Unknown8(OUT uint64_t& _0, OUT uint64_t& _1); + }; + class IShopServiceManager { + public: + IShopServiceManager(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::nim::detail::IAsyncData::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nim::detail::IAsyncData::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nim::detail::IAsyncData::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nim::detail::IAsyncData::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nim::detail::IAsyncData::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nim::detail::IAsyncProgressResult::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nim::detail::IAsyncProgressResult::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nim::detail::IAsyncProgressResult::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nim::detail::IAsyncResult::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nim::detail::IAsyncResult::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nim::detail::IAsyncValue::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nim::detail::IAsyncValue::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nim::detail::IAsyncValue::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nim::detail::INetworkInstallManager::Unknown2(IN uint8_t * _0, guint _0_size, OUT uint64_t& _1, OUT uint64_t& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::nim::detail::INetworkInstallManager::Unknown40(IN uint8_t * _0, guint _0_size, OUT uint64_t& _1, OUT uint64_t& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::nim::detail::INetworkInstallManager::Unknown8(OUT uint64_t& _0, OUT uint64_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::npns { + class INpnsSystem { + public: + INpnsSystem(); + uint32_t SetInterfaceVersion(OUT KObject * _0); + uint32_t Unknown103(OUT KObject * _0); + uint32_t Unknown7(OUT KObject * _0); + }; + class INpnsUser { + public: + INpnsUser(); + uint32_t Unknown1(); + uint32_t Unknown101(); + uint32_t Unknown102(); + uint32_t Unknown103(); + uint32_t Unknown104(); + uint32_t Unknown111(); + uint32_t Unknown2(); + uint32_t Unknown21(); + uint32_t Unknown23(); + uint32_t Unknown25(); + uint32_t Unknown3(); + uint32_t Unknown4(); + uint32_t Unknown5(); + uint32_t Unknown7(); + }; + class Weird { + public: + Weird(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::npns::INpnsSystem::SetInterfaceVersion(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::npns::INpnsSystem::Unknown103(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::npns::INpnsSystem::Unknown7(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::npns::INpnsUser::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::npns::INpnsUser::Unknown101() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::npns::INpnsUser::Unknown102() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::npns::INpnsUser::Unknown103() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::npns::INpnsUser::Unknown104() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::npns::INpnsUser::Unknown111() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::npns::INpnsUser::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::npns::INpnsUser::Unknown21() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::npns::INpnsUser::Unknown23() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::npns::INpnsUser::Unknown25() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::npns::INpnsUser::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::npns::INpnsUser::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::npns::INpnsUser::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::npns::INpnsUser::Unknown7() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::ns::detail { + class IAccountProxyInterface { + public: + IAccountProxyInterface(); + uint32_t Unknown0(); + }; + class IApplicationManagerInterface { + public: + IApplicationManagerInterface(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown100(); + uint32_t Unknown1000(); + uint32_t Unknown1001(); + uint32_t Unknown1002(); + uint32_t Unknown101(); + uint32_t Unknown102(); + uint32_t Unknown11(); + uint32_t Unknown1200(); + uint32_t Unknown1300(); + uint32_t Unknown1301(); + uint32_t Unknown1302(); + uint32_t Unknown1303(); + uint32_t Unknown1304(); + uint32_t Unknown1400(); + uint32_t Unknown1500(); + uint32_t Unknown1501(); + uint32_t Unknown1502(); + uint32_t Unknown1504(); + uint32_t Unknown1505(); + uint32_t Unknown16(); + uint32_t Unknown1600(); + uint32_t Unknown1601(); + uint32_t Unknown17(); + uint32_t Unknown1700(); + uint32_t Unknown1701(); + uint32_t Unknown1702(); + uint32_t Unknown1800(); + uint32_t Unknown1801(); + uint32_t Unknown1802(); + uint32_t Unknown1803(); + uint32_t Unknown19(); + uint32_t Unknown1900(); + uint32_t Unknown2(); + uint32_t Unknown200(); + uint32_t Unknown201(); + uint32_t Unknown21(); + uint32_t Unknown210(); + uint32_t Unknown22(); + uint32_t Unknown220(); + uint32_t Unknown23(); + uint32_t Unknown26(); + uint32_t Unknown27(); + uint32_t Unknown3(); + uint32_t Unknown30(); + uint32_t Unknown300(); + uint32_t Unknown301(); + uint32_t Unknown302(); + uint32_t Unknown303(); + uint32_t Unknown304(); + uint32_t Unknown305(); + uint32_t Unknown306(); + uint32_t Unknown307(); + uint32_t Unknown31(); + uint32_t Unknown32(); + uint32_t Unknown33(); + uint32_t Unknown35(); + uint32_t Unknown36(); + uint32_t Unknown37(); + uint32_t Unknown38(); + uint32_t Unknown39(); + uint32_t Unknown4(); + uint32_t Unknown40(); + uint32_t Unknown400(); + uint32_t Unknown401(); + uint32_t Unknown402(); + uint32_t Unknown403(); + uint32_t Unknown404(); + uint32_t Unknown405(); + uint32_t Unknown41(); + uint32_t Unknown42(); + uint32_t Unknown43(); + uint32_t Unknown44(); + uint32_t Unknown45(); + uint32_t Unknown46(); + uint32_t Unknown47(); + uint32_t Unknown48(); + uint32_t Unknown49(); + uint32_t Unknown5(); + uint32_t Unknown502(); + uint32_t Unknown503(); + uint32_t Unknown504(); + uint32_t Unknown505(); + uint32_t Unknown506(); + uint32_t Unknown507(); + uint32_t Unknown508(); + uint32_t Unknown52(); + uint32_t Unknown53(); + uint32_t Unknown54(); + uint32_t Unknown55(); + uint32_t Unknown56(); + uint32_t Unknown57(); + uint32_t Unknown58(); + uint32_t Unknown59(); + uint32_t Unknown6(); + uint32_t Unknown60(); + uint32_t Unknown600(); + uint32_t Unknown601(); + uint32_t Unknown602(); + uint32_t Unknown603(); + uint32_t Unknown604(); + uint32_t Unknown605(); + uint32_t Unknown606(); + uint32_t Unknown61(); + uint32_t Unknown62(); + uint32_t Unknown63(); + uint32_t Unknown64(); + uint32_t Unknown65(); + uint32_t Unknown66(); + uint32_t Unknown67(); + uint32_t Unknown68(); + uint32_t Unknown69(); + uint32_t Unknown7(); + uint32_t Unknown70(); + uint32_t Unknown700(); + uint32_t Unknown701(); + uint32_t Unknown702(); + uint32_t Unknown703(); + uint32_t Unknown704(); + uint32_t Unknown705(); + uint32_t Unknown71(); + uint32_t Unknown8(); + uint32_t Unknown80(); + uint32_t Unknown800(); + uint32_t Unknown801(); + uint32_t Unknown802(); + uint32_t Unknown81(); + uint32_t Unknown82(); + uint32_t Unknown9(); + uint32_t Unknown900(); + uint32_t Unknown901(); + uint32_t Unknown902(); + uint32_t Unknown903(); + uint32_t Unknown904(); + uint32_t Unknown905(); + uint32_t Unknown906(); + uint32_t Unknown907(); + uint32_t Unknown908(); + uint32_t Unknown909(); + }; + class IAsyncResult { + public: + IAsyncResult(); + uint32_t Unknown0(); + uint32_t Unknown1(); + }; + class IAsyncValue { + public: + IAsyncValue(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + }; + class IContentManagementInterface { + public: + IContentManagementInterface(); + uint32_t Unknown11(); + uint32_t Unknown43(); + uint32_t Unknown47(); + uint32_t Unknown48(); + uint32_t Unknown600(); + uint32_t Unknown601(); + uint32_t Unknown605(); + uint32_t Unknown607(); + }; + class IDevelopInterface { + public: + IDevelopInterface(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + uint32_t Unknown4(); + uint32_t Unknown5(); + uint32_t Unknown6(); + uint32_t Unknown7(); + uint32_t Unknown8(); + uint32_t Unknown9(); + }; + class IDocumentInterface { + public: + IDocumentInterface(); + uint32_t Unknown21(); + uint32_t Unknown23(); + }; + class IDownloadTaskInterface { + public: + IDownloadTaskInterface(); + uint32_t Unknown701(); + uint32_t Unknown702(); + uint32_t Unknown703(); + uint32_t Unknown704(); + uint32_t Unknown705(); + }; + class IFactoryResetInterface { + public: + IFactoryResetInterface(); + uint32_t Unknown100(); + uint32_t Unknown101(); + uint32_t Unknown102(); + }; + class IGameCardStopper { + public: + IGameCardStopper(); + }; + class IProgressAsyncResult { + public: + IProgressAsyncResult(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + uint32_t Unknown3(); + }; + class IProgressMonitorForDeleteUserSaveDataAll { + public: + IProgressMonitorForDeleteUserSaveDataAll(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown10(); + uint32_t Unknown2(); + }; + class IRequestServerStopper { + public: + IRequestServerStopper(); + }; + class IServiceGetterInterface { + public: + IServiceGetterInterface(); + uint32_t Unknown7994(); + uint32_t Unknown7995(); + uint32_t Unknown7996(); + uint32_t Unknown7997(); + uint32_t Unknown7998(); + uint32_t Unknown7999(); + }; + class ISystemUpdateControl { + public: + ISystemUpdateControl(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown10(); + uint32_t Unknown11(); + uint32_t Unknown12(); + uint32_t Unknown13(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + uint32_t Unknown5(); + uint32_t Unknown6(); + uint32_t Unknown7(); + uint32_t Unknown8(); + uint32_t Unknown9(); + }; + class ISystemUpdateInterface { + public: + ISystemUpdateInterface(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown10(); + uint32_t Unknown11(); + uint32_t Unknown12(); + uint32_t Unknown13(); + uint32_t Unknown14(); + uint32_t Unknown15(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + uint32_t Unknown5(); + uint32_t Unknown6(); + uint32_t Unknown9(); + }; + class IVulnerabilityManagerInterface { + public: + IVulnerabilityManagerInterface(); + uint32_t Unknown1200(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::ns::detail::IAccountProxyInterface::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown100() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown1000() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown1001() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown1002() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown101() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown102() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown11() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown1200() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown1300() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown1301() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown1302() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown1303() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown1304() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown1400() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown1500() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown1501() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown1502() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown1504() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown1505() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown16() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown1600() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown1601() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown17() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown1700() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown1701() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown1702() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown1800() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown1801() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown1802() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown1803() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown19() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown1900() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown200() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown201() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown21() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown210() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown22() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown220() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown23() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown26() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown27() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown30() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown300() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown301() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown302() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown303() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown304() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown305() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown306() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown307() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown31() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown32() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown33() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown35() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown36() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown37() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown38() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown39() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown40() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown400() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown401() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown402() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown403() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown404() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown405() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown41() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown42() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown43() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown44() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown45() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown46() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown47() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown48() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown49() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown502() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown503() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown504() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown505() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown506() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown507() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown508() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown52() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown53() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown54() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown55() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown56() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown57() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown58() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown59() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown6() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown60() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown600() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown601() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown602() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown603() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown604() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown605() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown606() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown61() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown62() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown63() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown64() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown65() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown66() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown67() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown68() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown69() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown7() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown70() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown700() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown701() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown702() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown703() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown704() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown705() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown71() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown8() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown80() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown800() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown801() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown802() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown81() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown82() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown9() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown900() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown901() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown902() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown903() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown904() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown905() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown906() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown907() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown908() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IApplicationManagerInterface::Unknown909() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IAsyncResult::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IAsyncResult::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IAsyncValue::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IAsyncValue::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IAsyncValue::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IContentManagementInterface::Unknown11() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IContentManagementInterface::Unknown43() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IContentManagementInterface::Unknown47() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IContentManagementInterface::Unknown48() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IContentManagementInterface::Unknown600() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IContentManagementInterface::Unknown601() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IContentManagementInterface::Unknown605() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IContentManagementInterface::Unknown607() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IDevelopInterface::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IDevelopInterface::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IDevelopInterface::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IDevelopInterface::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IDevelopInterface::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IDevelopInterface::Unknown6() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IDevelopInterface::Unknown7() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IDevelopInterface::Unknown8() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IDevelopInterface::Unknown9() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IDocumentInterface::Unknown21() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IDocumentInterface::Unknown23() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IDownloadTaskInterface::Unknown701() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IDownloadTaskInterface::Unknown702() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IDownloadTaskInterface::Unknown703() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IDownloadTaskInterface::Unknown704() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IDownloadTaskInterface::Unknown705() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IFactoryResetInterface::Unknown100() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IFactoryResetInterface::Unknown101() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IFactoryResetInterface::Unknown102() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IProgressAsyncResult::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IProgressAsyncResult::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IProgressAsyncResult::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IProgressAsyncResult::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IProgressMonitorForDeleteUserSaveDataAll::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IProgressMonitorForDeleteUserSaveDataAll::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IProgressMonitorForDeleteUserSaveDataAll::Unknown10() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IProgressMonitorForDeleteUserSaveDataAll::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IServiceGetterInterface::Unknown7994() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IServiceGetterInterface::Unknown7995() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IServiceGetterInterface::Unknown7996() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IServiceGetterInterface::Unknown7997() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IServiceGetterInterface::Unknown7998() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IServiceGetterInterface::Unknown7999() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::ISystemUpdateControl::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::ISystemUpdateControl::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::ISystemUpdateControl::Unknown10() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::ISystemUpdateControl::Unknown11() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::ISystemUpdateControl::Unknown12() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::ISystemUpdateControl::Unknown13() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::ISystemUpdateControl::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::ISystemUpdateControl::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::ISystemUpdateControl::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::ISystemUpdateControl::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::ISystemUpdateControl::Unknown6() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::ISystemUpdateControl::Unknown7() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::ISystemUpdateControl::Unknown8() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::ISystemUpdateControl::Unknown9() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::ISystemUpdateInterface::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::ISystemUpdateInterface::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::ISystemUpdateInterface::Unknown10() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::ISystemUpdateInterface::Unknown11() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::ISystemUpdateInterface::Unknown12() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::ISystemUpdateInterface::Unknown13() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::ISystemUpdateInterface::Unknown14() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::ISystemUpdateInterface::Unknown15() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::ISystemUpdateInterface::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::ISystemUpdateInterface::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::ISystemUpdateInterface::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::ISystemUpdateInterface::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::ISystemUpdateInterface::Unknown6() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::ISystemUpdateInterface::Unknown9() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ns::detail::IVulnerabilityManagerInterface::Unknown1200() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::nsd::detail { + class IManager { + public: + IManager(); + uint32_t Unknown10(OUT uint8_t * _0, guint _0_size); + uint32_t Unknown11(OUT uint8_t * _0, guint _0_size); + uint32_t Unknown12(OUT uint128_t& _0); + uint32_t Unknown13(IN uint32_t _0); + uint32_t Unknown14(IN uint32_t _0, IN uint8_t * _1, guint _1_size, OUT uint8_t * _2, guint _2_size); + uint32_t Unknown20(IN uint8_t * _0, guint _0_size, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown21(IN uint8_t * _0, guint _0_size, OUT uint32_t& _1, OUT uint8_t * _2, guint _2_size); + uint32_t Unknown30(IN uint8_t * _0, guint _0_size, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown31(IN uint8_t * _0, guint _0_size, OUT uint32_t& _1, OUT uint8_t * _2, guint _2_size); + uint32_t Unknown40(OUT uint8_t * _0, guint _0_size); + uint32_t Unknown41(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown42(OUT uint8_t * _0, guint _0_size); + uint32_t Unknown43(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown50(OUT uint8_t * _0, guint _0_size); + uint32_t Unknown60(OUT uint8_t * _0, guint _0_size); + uint32_t Unknown61(IN uint8_t * _0, guint _0_size); + uint32_t Unknown62(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::nsd::detail::IManager::Unknown10(OUT uint8_t * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x16, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nsd::detail::IManager::Unknown11(OUT uint8_t * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x16, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nsd::detail::IManager::Unknown12(OUT uint128_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nsd::detail::IManager::Unknown13(IN uint32_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::nsd::detail::IManager::Unknown14(IN uint32_t _0, IN uint8_t * _1, guint _1_size, OUT uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(6, 0, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +uint32_t nn::nsd::detail::IManager::Unknown20(IN uint8_t * _0, guint _0_size, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x15, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(0x16, 0, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +uint32_t nn::nsd::detail::IManager::Unknown21(IN uint8_t * _0, guint _0_size, OUT uint32_t& _1, OUT uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x15, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(0x16, 0, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +uint32_t nn::nsd::detail::IManager::Unknown30(IN uint8_t * _0, guint _0_size, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x15, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(0x16, 0, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +uint32_t nn::nsd::detail::IManager::Unknown31(IN uint8_t * _0, guint _0_size, OUT uint32_t& _1, OUT uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x15, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(0x16, 0, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +uint32_t nn::nsd::detail::IManager::Unknown40(OUT uint8_t * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x16, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nsd::detail::IManager::Unknown41(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x16, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nsd::detail::IManager::Unknown42(OUT uint8_t * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x16, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nsd::detail::IManager::Unknown43(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x16, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nsd::detail::IManager::Unknown50(OUT uint8_t * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x16, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nsd::detail::IManager::Unknown60(OUT uint8_t * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x16, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::nsd::detail::IManager::Unknown61(IN uint8_t * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x15, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::nsd::detail::IManager::Unknown62() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::ntc::detail::service { + class IEnsureNetworkClockAvailabilityService { + public: + IEnsureNetworkClockAvailabilityService(); + uint32_t Unknown0(); + uint32_t Unknown1(OUT KObject * _0); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(OUT uint8_t& _0); + uint32_t Unknown5(OUT uint64_t& _0); + }; + class IStaticService { + public: + IStaticService(); + uint32_t Unknown0(IN uint32_t _0, IN uint32_t _1, OUT IUnknown * _2); + uint32_t Unknown100(); + uint32_t Unknown101(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::ntc::detail::service::IEnsureNetworkClockAvailabilityService::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ntc::detail::service::IEnsureNetworkClockAvailabilityService::Unknown1(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::ntc::detail::service::IEnsureNetworkClockAvailabilityService::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ntc::detail::service::IEnsureNetworkClockAvailabilityService::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ntc::detail::service::IEnsureNetworkClockAvailabilityService::Unknown4(OUT uint8_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ntc::detail::service::IEnsureNetworkClockAvailabilityService::Unknown5(OUT uint64_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ntc::detail::service::IStaticService::Unknown0(IN uint32_t _0, IN uint32_t _1, OUT IUnknown * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _2 OMG = new IUnknown(resp.move_handles[0]); + return ret; +} +uint32_t nn::ntc::detail::service::IStaticService::Unknown100() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ntc::detail::service::IStaticService::Unknown101() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::omm::detail { + class IOperationModeManager { + public: + IOperationModeManager(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown10(); + uint32_t Unknown11(); + uint32_t Unknown12(); + uint32_t Unknown13(); + uint32_t Unknown14(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + uint32_t Unknown5(); + uint32_t Unknown6(); + uint32_t Unknown7(); + uint32_t Unknown8(); + uint32_t Unknown9(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::omm::detail::IOperationModeManager::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::omm::detail::IOperationModeManager::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::omm::detail::IOperationModeManager::Unknown10() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::omm::detail::IOperationModeManager::Unknown11() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::omm::detail::IOperationModeManager::Unknown12() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::omm::detail::IOperationModeManager::Unknown13() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::omm::detail::IOperationModeManager::Unknown14() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::omm::detail::IOperationModeManager::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::omm::detail::IOperationModeManager::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::omm::detail::IOperationModeManager::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::omm::detail::IOperationModeManager::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::omm::detail::IOperationModeManager::Unknown6() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::omm::detail::IOperationModeManager::Unknown7() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::omm::detail::IOperationModeManager::Unknown8() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::omm::detail::IOperationModeManager::Unknown9() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::ovln { + class IReceiver { + public: + IReceiver(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + }; + class IReceiverService { + public: + IReceiverService(); + uint32_t Unknown0(); + }; + class ISender { + public: + ISender(); + uint32_t Unknown0(IN uint64_t unk1, IN uint64_t unk2, IN uint64_t unk3, IN uint64_t unk4, IN uint64_t unk5, IN uint64_t unk6, IN uint64_t unk7, IN uint64_t unk8, IN uint64_t unk9, IN uint64_t unk10, IN uint64_t unk11, IN uint64_t unk12, IN uint64_t unk13, IN uint64_t unk14, IN uint64_t unk15, IN uint64_t unk16, IN uint64_t unk17); + }; + class ISenderService { + public: + ISenderService(); + uint32_t Unknown0(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::ovln::IReceiver::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ovln::IReceiver::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ovln::IReceiver::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ovln::IReceiver::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ovln::IReceiver::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ovln::IReceiverService::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ovln::ISender::Unknown0(IN uint64_t unk1, IN uint64_t unk2, IN uint64_t unk3, IN uint64_t unk4, IN uint64_t unk5, IN uint64_t unk6, IN uint64_t unk7, IN uint64_t unk8, IN uint64_t unk9, IN uint64_t unk10, IN uint64_t unk11, IN uint64_t unk12, IN uint64_t unk13, IN uint64_t unk14, IN uint64_t unk15, IN uint64_t unk16, IN uint64_t unk17) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ovln::ISenderService::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::pcie::detail { + class IManager { + public: + IManager(); + uint32_t Unknown0(); + uint32_t Unknown1(); + }; + class ISession { + public: + ISession(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown10(); + uint32_t Unknown11(); + uint32_t Unknown12(); + uint32_t Unknown13(); + uint32_t Unknown14(); + uint32_t Unknown15(); + uint32_t Unknown16(); + uint32_t Unknown17(); + uint32_t Unknown18(); + uint32_t Unknown19(); + uint32_t Unknown2(); + uint32_t Unknown20(); + uint32_t Unknown21(); + uint32_t Unknown3(); + uint32_t Unknown4(); + uint32_t Unknown5(); + uint32_t Unknown6(); + uint32_t Unknown7(); + uint32_t Unknown8(); + uint32_t Unknown9(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::pcie::detail::IManager::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcie::detail::IManager::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcie::detail::ISession::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcie::detail::ISession::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcie::detail::ISession::Unknown10() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcie::detail::ISession::Unknown11() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcie::detail::ISession::Unknown12() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcie::detail::ISession::Unknown13() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcie::detail::ISession::Unknown14() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcie::detail::ISession::Unknown15() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcie::detail::ISession::Unknown16() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcie::detail::ISession::Unknown17() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcie::detail::ISession::Unknown18() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcie::detail::ISession::Unknown19() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcie::detail::ISession::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcie::detail::ISession::Unknown20() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcie::detail::ISession::Unknown21() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcie::detail::ISession::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcie::detail::ISession::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcie::detail::ISession::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcie::detail::ISession::Unknown6() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcie::detail::ISession::Unknown7() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcie::detail::ISession::Unknown8() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcie::detail::ISession::Unknown9() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::pctl::detail::ipc { + class IParentalControlService { + public: + IParentalControlService(); + uint32_t AddToFreeCommunicationApplicationList(IN nn::ncm::ApplicationId _0); + uint32_t AuthorizePairingAsync(IN nn::pctl::detail::PairingInfoBase _0, OUT nn::pctl::detail::AsyncData& _1, OUT KObject * _2); + uint32_t CancelNetworkRequest(); + uint32_t CheckFreeCommunicationPermission(); + uint32_t CheckMasterKey(IN nn::pctl::InquiryCode _0, IN int8_t * _1, guint _1_size, OUT bool& _2); + uint32_t ClearFreeCommunicationApplicationListForDebug(); + uint32_t ClearUnlinkedEvent(); + uint32_t ConfirmLaunchApplicationPermission(IN bool _0, IN nn::ncm::ApplicationId _1, IN int8_t * _2, guint _2_size); + uint32_t ConfirmResumeApplicationPermission(IN bool _0, IN nn::ncm::ApplicationId _1, IN int8_t * _2, guint _2_size); + uint32_t ConfirmSnsPostPermission(); + uint32_t ConfirmSystemSettingsPermission(); + uint32_t DeleteFromFreeCommunicationApplicationListForDebug(IN nn::ncm::ApplicationId _0); + uint32_t DeletePairing(); + uint32_t DeleteSettings(); + uint32_t DisableAllFeatures(OUT bool& _0); + uint32_t DisableFeaturesForReset(); + uint32_t EnterRestrictedSystemSettings(); + uint32_t FinishAuthorizePairing(IN nn::pctl::detail::AsyncData _0, OUT nn::pctl::detail::PairingInfoBase& _1); + uint32_t FinishGetAccountMiiImage(IN nn::pctl::detail::AsyncData _0, OUT uint32_t& _1, OUT uint8_t * _2, guint _2_size); + uint32_t FinishGetAccountMiiImageContentType(IN nn::pctl::detail::AsyncData _0, OUT uint32_t& _1, OUT int8_t * _2, guint _2_size); + uint32_t FinishRequestPairing(IN nn::pctl::detail::AsyncData _0, OUT nn::pctl::detail::PairingInfoBase& _1); + uint32_t FinishRetrievePairingInfo(IN nn::pctl::detail::AsyncData _0, OUT nn::pctl::detail::PairingInfoBase& _1); + uint32_t FinishSynchronizeParentalControlSettings(IN nn::pctl::detail::AsyncData _0); + uint32_t FinishSynchronizeParentalControlSettingsWithLastUpdated(IN nn::pctl::detail::AsyncData _0, OUT nn::time::PosixTime& _1); + uint32_t FinishUnlinkPairing(IN bool _0, IN nn::pctl::detail::AsyncData _1); + uint32_t GenerateInquiryCode(OUT nn::pctl::InquiryCode& _0); + uint32_t GetAccountMiiImageAsync(IN nn::pctl::detail::PairingAccountInfoBase _0, OUT nn::pctl::detail::AsyncData& _1, OUT uint32_t& _2, OUT KObject * _3, OUT uint8_t * _4, guint _4_size); + uint32_t GetAccountMiiImageContentTypeAsync(IN nn::pctl::detail::PairingAccountInfoBase _0, OUT nn::pctl::detail::AsyncData& _1, OUT uint32_t& _2, OUT KObject * _3, OUT int8_t * _4, guint _4_size); + uint32_t GetAccountNickname(IN nn::pctl::detail::PairingAccountInfoBase _0, OUT uint32_t& _1, OUT int8_t * _2, guint _2_size); + uint32_t GetAccountState(IN nn::pctl::detail::PairingAccountInfoBase _0, OUT int32_t& _1); + uint32_t GetCurrentSettings(OUT nn::pctl::SafetyLevelSettings& _0); + uint32_t GetDefaultRatingOrganization(OUT int32_t& _0); + uint32_t GetFreeCommunicationApplicationList(IN int32_t _0, OUT int32_t& _1, OUT nn::pctl::FreeCommunicationApplicationInfo * _2, guint _2_size); + uint32_t GetFreeCommunicationApplicationListCount(OUT int32_t& _0); + uint32_t GetPairingAccountInfo(IN nn::pctl::detail::PairingInfoBase _0, OUT nn::pctl::detail::PairingAccountInfoBase& _1); + uint32_t GetPinCodeChangedEvent(OUT KObject * _0); + uint32_t GetPinCodeLength(OUT int32_t& _0); + uint32_t GetPlayTimerEventToRequestSuspension(OUT KObject * _0); + uint32_t GetPlayTimerRemainingTime(OUT nn::TimeSpanType& _0); + uint32_t GetPlayTimerSettings(OUT nn::pctl::PlayTimerSettings& _0); + uint32_t GetPlayTimerSpentTimeForTest(OUT nn::TimeSpanType& _0); + uint32_t GetRestrictedFeatures(OUT int32_t& _0); + uint32_t GetSafetyLevel(OUT int32_t& _0); + uint32_t GetSafetyLevelSettings(IN int32_t _0, OUT nn::pctl::SafetyLevelSettings& _1); + uint32_t GetSettingsLastUpdated(OUT nn::time::PosixTime& _0); + uint32_t GetSynchronizationEvent(OUT KObject * _0); + uint32_t GetUnlinkedEvent(OUT KObject * _0); + uint32_t IsAllFeaturesDisabled(OUT bool& _0, OUT bool& _1); + uint32_t IsPairingActive(OUT bool& _0); + uint32_t IsPlayTimerEnabled(OUT bool& _0); + uint32_t IsRestrictedByPlayTimer(OUT bool& _0); + uint32_t IsRestrictedSystemSettingsEntered(OUT bool& _0); + uint32_t IsRestrictionEnabled(OUT bool& _0); + uint32_t IsRestrictionTemporaryUnlocked(OUT bool& _0); + uint32_t LeaveRestrictedSystemSettings(); + uint32_t NotifyApplicationDownloadStarted(IN nn::ncm::ApplicationId _0); + uint32_t NotifyWrongPinCodeInputManyTimes(); + uint32_t PostEnableAllFeatures(OUT bool& _0); + uint32_t RequestPairingAsync(IN int8_t * _0, guint _0_size, OUT nn::pctl::detail::AsyncData& _1, OUT KObject * _2); + uint32_t RetrievePairingInfoAsync(OUT nn::pctl::detail::AsyncData& _0, OUT KObject * _1); + uint32_t RevertRestrictedSystemSettingsEntered(); + uint32_t RevertRestrictionTemporaryUnlocked(); + uint32_t SetCustomSafetyLevelSettings(IN nn::pctl::SafetyLevelSettings _0); + uint32_t SetDefaultRatingOrganization(IN int32_t _0); + uint32_t SetPinCode(IN int8_t * _0, guint _0_size); + uint32_t SetPlayTimerSettingsForDebug(IN nn::pctl::PlayTimerSettings _0); + uint32_t SetSafetyLevel(IN int32_t _0); + uint32_t StartPlayTimer(); + uint32_t StopPlayTimer(); + uint32_t SynchronizeParentalControlSettingsAsync(OUT nn::pctl::detail::AsyncData& _0, OUT KObject * _1); + uint32_t UnlinkPairingAsync(IN bool _0, OUT nn::pctl::detail::AsyncData& _1, OUT KObject * _2); + uint32_t UnlockRestrictionTemporarily(IN int8_t * _0, guint _0_size); + uint32_t UnlockSystemSettingsRestriction(IN int8_t * _0, guint _0_size); + uint32_t UpdateFreeCommunicationApplicationList(IN nn::pctl::FreeCommunicationApplicationInfo * _0, guint _0_size); + }; + class IParentalControlServiceFactory { + public: + IParentalControlServiceFactory(); + uint32_t CreateService(IN uint64_t _0, IN gpid _1, OUT nn::pctl::detail::ipc::IParentalControlService * _2); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::pctl::detail::ipc::IParentalControlService::AddToFreeCommunicationApplicationList(IN nn::ncm::ApplicationId _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::AuthorizePairingAsync(IN nn::pctl::detail::PairingInfoBase _0, OUT nn::pctl::detail::AsyncData& _1, OUT KObject * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::CancelNetworkRequest() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::CheckFreeCommunicationPermission() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::CheckMasterKey(IN nn::pctl::InquiryCode _0, IN int8_t * _1, guint _1_size, OUT bool& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(9, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::ClearFreeCommunicationApplicationListForDebug() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::ClearUnlinkedEvent() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::ConfirmLaunchApplicationPermission(IN bool _0, IN nn::ncm::ApplicationId _1, IN int8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(9, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::ConfirmResumeApplicationPermission(IN bool _0, IN nn::ncm::ApplicationId _1, IN int8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(9, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::ConfirmSnsPostPermission() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::ConfirmSystemSettingsPermission() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::DeleteFromFreeCommunicationApplicationListForDebug(IN nn::ncm::ApplicationId _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::DeletePairing() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::DeleteSettings() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::DisableAllFeatures(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::DisableFeaturesForReset() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::EnterRestrictedSystemSettings() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::FinishAuthorizePairing(IN nn::pctl::detail::AsyncData _0, OUT nn::pctl::detail::PairingInfoBase& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::FinishGetAccountMiiImage(IN nn::pctl::detail::AsyncData _0, OUT uint32_t& _1, OUT uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::FinishGetAccountMiiImageContentType(IN nn::pctl::detail::AsyncData _0, OUT uint32_t& _1, OUT int8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0xa, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::FinishRequestPairing(IN nn::pctl::detail::AsyncData _0, OUT nn::pctl::detail::PairingInfoBase& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::FinishRetrievePairingInfo(IN nn::pctl::detail::AsyncData _0, OUT nn::pctl::detail::PairingInfoBase& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::FinishSynchronizeParentalControlSettings(IN nn::pctl::detail::AsyncData _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::FinishSynchronizeParentalControlSettingsWithLastUpdated(IN nn::pctl::detail::AsyncData _0, OUT nn::time::PosixTime& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::FinishUnlinkPairing(IN bool _0, IN nn::pctl::detail::AsyncData _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::GenerateInquiryCode(OUT nn::pctl::InquiryCode& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::GetAccountMiiImageAsync(IN nn::pctl::detail::PairingAccountInfoBase _0, OUT nn::pctl::detail::AsyncData& _1, OUT uint32_t& _2, OUT KObject * _3, OUT uint8_t * _4, guint _4_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + guint temp3; + auto temp2 = req.getBuffer(6, 0, temp3); + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + ctu->cpu.writemem(temp2, temp4, temp3); + delete[] temp4; + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::GetAccountMiiImageContentTypeAsync(IN nn::pctl::detail::PairingAccountInfoBase _0, OUT nn::pctl::detail::AsyncData& _1, OUT uint32_t& _2, OUT KObject * _3, OUT int8_t * _4, guint _4_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + guint temp3; + auto temp2 = req.getBuffer(0xa, 0, temp3); + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + ctu->cpu.writemem(temp2, temp4, temp3); + delete[] temp4; + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::GetAccountNickname(IN nn::pctl::detail::PairingAccountInfoBase _0, OUT uint32_t& _1, OUT int8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0xa, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::GetAccountState(IN nn::pctl::detail::PairingAccountInfoBase _0, OUT int32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::GetCurrentSettings(OUT nn::pctl::SafetyLevelSettings& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(9); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::GetDefaultRatingOrganization(OUT int32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::GetFreeCommunicationApplicationList(IN int32_t _0, OUT int32_t& _1, OUT nn::pctl::FreeCommunicationApplicationInfo * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::GetFreeCommunicationApplicationListCount(OUT int32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::GetPairingAccountInfo(IN nn::pctl::detail::PairingInfoBase _0, OUT nn::pctl::detail::PairingAccountInfoBase& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::GetPinCodeChangedEvent(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::GetPinCodeLength(OUT int32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::GetPlayTimerEventToRequestSuspension(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::GetPlayTimerRemainingTime(OUT nn::TimeSpanType& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::GetPlayTimerSettings(OUT nn::pctl::PlayTimerSettings& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::GetPlayTimerSpentTimeForTest(OUT nn::TimeSpanType& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::GetRestrictedFeatures(OUT int32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::GetSafetyLevel(OUT int32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::GetSafetyLevelSettings(IN int32_t _0, OUT nn::pctl::SafetyLevelSettings& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(9); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::GetSettingsLastUpdated(OUT nn::time::PosixTime& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::GetSynchronizationEvent(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::GetUnlinkedEvent(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::IsAllFeaturesDisabled(OUT bool& _0, OUT bool& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::IsPairingActive(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::IsPlayTimerEnabled(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::IsRestrictedByPlayTimer(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::IsRestrictedSystemSettingsEntered(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::IsRestrictionEnabled(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::IsRestrictionTemporaryUnlocked(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::LeaveRestrictedSystemSettings() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::NotifyApplicationDownloadStarted(IN nn::ncm::ApplicationId _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::NotifyWrongPinCodeInputManyTimes() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::PostEnableAllFeatures(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::RequestPairingAsync(IN int8_t * _0, guint _0_size, OUT nn::pctl::detail::AsyncData& _1, OUT KObject * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(9, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + shared_ptr temp4; + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + if(temp4 != nullptr) + resp.copy(0, ctu->newHandle(temp4)); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::RetrievePairingInfoAsync(OUT nn::pctl::detail::AsyncData& _0, OUT KObject * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::RevertRestrictedSystemSettingsEntered() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::RevertRestrictionTemporaryUnlocked() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::SetCustomSafetyLevelSettings(IN nn::pctl::SafetyLevelSettings _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::SetDefaultRatingOrganization(IN int32_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::SetPinCode(IN int8_t * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(9, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::SetPlayTimerSettingsForDebug(IN nn::pctl::PlayTimerSettings _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::SetSafetyLevel(IN int32_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::StartPlayTimer() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::StopPlayTimer() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::SynchronizeParentalControlSettingsAsync(OUT nn::pctl::detail::AsyncData& _0, OUT KObject * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::UnlinkPairingAsync(IN bool _0, OUT nn::pctl::detail::AsyncData& _1, OUT KObject * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::UnlockRestrictionTemporarily(IN int8_t * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(9, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::UnlockSystemSettingsRestriction(IN int8_t * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(9, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlService::UpdateFreeCommunicationApplicationList(IN nn::pctl::FreeCommunicationApplicationInfo * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::pctl::detail::ipc::IParentalControlServiceFactory::CreateService(IN uint64_t _0, IN gpid _1, OUT nn::pctl::detail::ipc::IParentalControlService * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _2 OMG = new nn::pctl::detail::ipc::IParentalControlService(resp.move_handles[0]); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::pcv { + class IArbitrationManager { + public: + IArbitrationManager(); + uint32_t ReleaseControl(IN int32_t _0); + }; + class IImmediateManager { + public: + IImmediateManager(); + uint32_t SetClockRate(IN int32_t _0, IN uint32_t _1); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::pcv::IArbitrationManager::ReleaseControl(IN int32_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcv::IImmediateManager::SetClockRate(IN int32_t _0, IN uint32_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::pcv::detail { + class IPcvService { + public: + IPcvService(); + uint32_t ChangeVoltage(IN nn::pcv::PowerControlTarget _0, IN int32_t _1); + uint32_t Finalize(); + uint32_t GetClockRate(IN int32_t _0, OUT uint32_t& _1); + uint32_t GetDvfsTable(IN int32_t _0, IN int32_t _1, OUT int32_t& _2, OUT uint32_t * _3, guint _3_size, OUT int32_t * _4, guint _4_size); + uint32_t GetFuseInfo(IN int32_t _0, OUT int32_t& _1, OUT uint32_t * _2, guint _2_size); + uint32_t GetModuleStateTable(IN int32_t _0, OUT int32_t& _1, OUT nn::pcv::ModuleState * _2, guint _2_size); + uint32_t GetOscillatorClock(OUT uint32_t& _0); + uint32_t GetPossibleClockRates(IN int32_t _0, IN int32_t _1, OUT int32_t& _2, OUT int32_t& _3, OUT uint32_t * _4, guint _4_size); + uint32_t GetPowerClockInfoEvent(OUT KObject * _0); + uint32_t GetPowerDomainStateTable(IN int32_t _0, OUT int32_t& _1, OUT nn::pcv::PowerDomainState * _2, guint _2_size); + uint32_t GetState(IN int32_t _0, OUT nn::pcv::ModuleState& _1); + uint32_t GetTemperatureThresholds(IN int32_t _0, OUT int32_t& _1, OUT nn::pcv::TemperatureThreshold * _2, guint _2_size); + uint32_t GetVoltageEnabled(IN int32_t _0, OUT bool& _1); + uint32_t GetVoltageRange(IN int32_t _0, OUT int32_t& _1, OUT int32_t& _2, OUT int32_t& _3); + uint32_t GetVoltageValue(IN int32_t _0, OUT int32_t& _1); + uint32_t Initialize(); + uint32_t IsInitialized(OUT bool& _0); + uint32_t PowerOff(IN nn::pcv::PowerControlTarget _0); + uint32_t PowerOn(IN nn::pcv::PowerControlTarget _0, IN int32_t _1); + uint32_t SetClockEnabled(IN bool _0, IN int32_t _1); + uint32_t SetClockRate(IN int32_t _0, IN uint32_t _1); + uint32_t SetMinVClockRate(IN int32_t _0, IN uint32_t _1); + uint32_t SetPowerEnabled(IN bool _0, IN int32_t _1); + uint32_t SetReset(IN bool _0, IN int32_t _1); + uint32_t SetTemperature(IN int32_t _0); + uint32_t SetVoltageEnabled(IN bool _0, IN int32_t _1); + uint32_t SetVoltageValue(IN int32_t _0, IN int32_t _1); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::pcv::detail::IPcvService::ChangeVoltage(IN nn::pcv::PowerControlTarget _0, IN int32_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcv::detail::IPcvService::Finalize() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcv::detail::IPcvService::GetClockRate(IN int32_t _0, OUT uint32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcv::detail::IPcvService::GetDvfsTable(IN int32_t _0, IN int32_t _1, OUT int32_t& _2, OUT uint32_t * _3, guint _3_size, OUT int32_t * _4, guint _4_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0xa, 0, temp2); + guint temp5; + auto temp4 = req.getBuffer(0xa, 1, temp5); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +uint32_t nn::pcv::detail::IPcvService::GetFuseInfo(IN int32_t _0, OUT int32_t& _1, OUT uint32_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0xa, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::pcv::detail::IPcvService::GetModuleStateTable(IN int32_t _0, OUT int32_t& _1, OUT nn::pcv::ModuleState * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0xa, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::pcv::detail::IPcvService::GetOscillatorClock(OUT uint32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcv::detail::IPcvService::GetPossibleClockRates(IN int32_t _0, IN int32_t _1, OUT int32_t& _2, OUT int32_t& _3, OUT uint32_t * _4, guint _4_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0xa, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::pcv::detail::IPcvService::GetPowerClockInfoEvent(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::pcv::detail::IPcvService::GetPowerDomainStateTable(IN int32_t _0, OUT int32_t& _1, OUT nn::pcv::PowerDomainState * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0xa, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::pcv::detail::IPcvService::GetState(IN int32_t _0, OUT nn::pcv::ModuleState& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcv::detail::IPcvService::GetTemperatureThresholds(IN int32_t _0, OUT int32_t& _1, OUT nn::pcv::TemperatureThreshold * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0xa, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::pcv::detail::IPcvService::GetVoltageEnabled(IN int32_t _0, OUT bool& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcv::detail::IPcvService::GetVoltageRange(IN int32_t _0, OUT int32_t& _1, OUT int32_t& _2, OUT int32_t& _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcv::detail::IPcvService::GetVoltageValue(IN int32_t _0, OUT int32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcv::detail::IPcvService::Initialize() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcv::detail::IPcvService::IsInitialized(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcv::detail::IPcvService::PowerOff(IN nn::pcv::PowerControlTarget _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcv::detail::IPcvService::PowerOn(IN nn::pcv::PowerControlTarget _0, IN int32_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcv::detail::IPcvService::SetClockEnabled(IN bool _0, IN int32_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcv::detail::IPcvService::SetClockRate(IN int32_t _0, IN uint32_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcv::detail::IPcvService::SetMinVClockRate(IN int32_t _0, IN uint32_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcv::detail::IPcvService::SetPowerEnabled(IN bool _0, IN int32_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcv::detail::IPcvService::SetReset(IN bool _0, IN int32_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcv::detail::IPcvService::SetTemperature(IN int32_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcv::detail::IPcvService::SetVoltageEnabled(IN bool _0, IN int32_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pcv::detail::IPcvService::SetVoltageValue(IN int32_t _0, IN int32_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::pdm::detail { + class INotifyService { + public: + INotifyService(); + uint32_t Unknown0(IN uint64_t _0, IN uint64_t _1); + uint32_t Unknown2(IN uint8_t _0); + uint32_t Unknown3(IN uint8_t _0); + uint32_t Unknown4(); + uint32_t Unknown5(IN uint8_t * _0, guint _0_size); + }; + class IQueryService { + public: + IQueryService(); + uint32_t Unknown0(IN uint32_t _0, OUT uint32_t& _1, OUT uint8_t * _2, guint _2_size); + uint32_t Unknown1(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown10(IN uint32_t _0, OUT uint32_t& _1, OUT uint8_t * _2, guint _2_size); + uint32_t Unknown2(IN uint64_t _0, IN uint64_t _1, OUT uint32_t& _2, OUT uint8_t * _3, guint _3_size); + uint32_t Unknown3(IN uint64_t _0, OUT uint32_t& _1, OUT uint8_t * _2, guint _2_size); + uint32_t Unknown4(IN uint64_t _0, OUT uint64_t& _1, OUT uint64_t& _2, OUT uint64_t& _3, OUT uint64_t& _4, OUT uint64_t& _5); + uint32_t Unknown5(IN uint64_t _0, IN uint64_t _1, IN uint64_t _2, OUT uint64_t& _3, OUT uint64_t& _4, OUT uint64_t& _5, OUT uint64_t& _6, OUT uint64_t& _7); + uint32_t Unknown6(IN uint64_t _0, IN uint64_t _1, OUT uint64_t& _2, OUT uint64_t& _3, OUT uint64_t& _4, OUT uint64_t& _5, OUT uint64_t& _6); + uint32_t Unknown7(IN uint8_t * _0, guint _0_size, OUT uint32_t& _1, OUT uint8_t * _2, guint _2_size); + uint32_t Unknown8(IN uint32_t _0, OUT uint32_t& _1, OUT uint8_t * _2, guint _2_size); + uint32_t Unknown9(OUT uint32_t& _0, OUT uint32_t& _1, OUT uint32_t& _2); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::pdm::detail::INotifyService::Unknown0(IN uint64_t _0, IN uint64_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pdm::detail::INotifyService::Unknown2(IN uint8_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pdm::detail::INotifyService::Unknown3(IN uint8_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pdm::detail::INotifyService::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pdm::detail::INotifyService::Unknown5(IN uint8_t * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::pdm::detail::IQueryService::Unknown0(IN uint32_t _0, OUT uint32_t& _1, OUT uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::pdm::detail::IQueryService::Unknown1(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::pdm::detail::IQueryService::Unknown10(IN uint32_t _0, OUT uint32_t& _1, OUT uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::pdm::detail::IQueryService::Unknown2(IN uint64_t _0, IN uint64_t _1, OUT uint32_t& _2, OUT uint8_t * _3, guint _3_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::pdm::detail::IQueryService::Unknown3(IN uint64_t _0, OUT uint32_t& _1, OUT uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::pdm::detail::IQueryService::Unknown4(IN uint64_t _0, OUT uint64_t& _1, OUT uint64_t& _2, OUT uint64_t& _3, OUT uint64_t& _4, OUT uint64_t& _5) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pdm::detail::IQueryService::Unknown5(IN uint64_t _0, IN uint64_t _1, IN uint64_t _2, OUT uint64_t& _3, OUT uint64_t& _4, OUT uint64_t& _5, OUT uint64_t& _6, OUT uint64_t& _7) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pdm::detail::IQueryService::Unknown6(IN uint64_t _0, IN uint64_t _1, OUT uint64_t& _2, OUT uint64_t& _3, OUT uint64_t& _4, OUT uint64_t& _5, OUT uint64_t& _6) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pdm::detail::IQueryService::Unknown7(IN uint8_t * _0, guint _0_size, OUT uint32_t& _1, OUT uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(6, 0, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +uint32_t nn::pdm::detail::IQueryService::Unknown8(IN uint32_t _0, OUT uint32_t& _1, OUT uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::pdm::detail::IQueryService::Unknown9(OUT uint32_t& _0, OUT uint32_t& _1, OUT uint32_t& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::pinmux { + class IManager { + public: + IManager(); + uint32_t Unknown0(); + }; + class ISession { + public: + ISession(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::pinmux::IManager::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pinmux::ISession::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pinmux::ISession::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pinmux::ISession::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::pl::detail { + class ISharedFontManager { + public: + ISharedFontManager(); + uint32_t Unknown0(IN uint32_t _0); + uint32_t Unknown1(IN uint32_t _0, OUT uint32_t& _1); + uint32_t Unknown2(IN uint32_t _0, OUT uint32_t& _1); + uint32_t Unknown3(IN uint32_t _0, OUT uint32_t& _1); + uint32_t Unknown4(OUT KObject * _0); + uint32_t Unknown5(IN uint64_t _0, OUT uint8_t& _1, OUT uint32_t& _2, OUT uint8_t * _3, guint _3_size, OUT uint8_t * _4, guint _4_size, OUT uint8_t * _5, guint _5_size); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::pl::detail::ISharedFontManager::Unknown0(IN uint32_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pl::detail::ISharedFontManager::Unknown1(IN uint32_t _0, OUT uint32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pl::detail::ISharedFontManager::Unknown2(IN uint32_t _0, OUT uint32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pl::detail::ISharedFontManager::Unknown3(IN uint32_t _0, OUT uint32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pl::detail::ISharedFontManager::Unknown4(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::pl::detail::ISharedFontManager::Unknown5(IN uint64_t _0, OUT uint8_t& _1, OUT uint32_t& _2, OUT uint8_t * _3, guint _3_size, OUT uint8_t * _4, guint _4_size, OUT uint8_t * _5, guint _5_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + guint temp5; + auto temp4 = req.getBuffer(6, 1, temp5); + guint temp8; + auto temp7 = req.getBuffer(6, 2, temp8); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + ctu->cpu.writemem(temp7, temp9, temp8); + delete[] temp9; + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::prepo::detail::ipc { + class IPrepoService { + public: + IPrepoService(); + uint32_t ClearStorage(); + uint32_t GetStorageUsage(OUT int64_t& _0, OUT int64_t& _1); + uint32_t GetTransmissionStatus(OUT int32_t& _0); + uint32_t IsUserAgreementCheckEnabled(OUT bool& _0); + uint32_t RequestImmediateTransmission(); + uint32_t SaveReport(IN uint64_t _0, IN gpid _1, IN int8_t * _2, guint _2_size, IN uint8_t * _3, guint _3_size); + uint32_t SaveReportWithUser(IN nn::account::Uid _0, IN uint64_t _1, IN gpid _2, IN int8_t * _3, guint _3_size, IN uint8_t * _4, guint _4_size); + uint32_t SaveSystemReport(IN nn::ApplicationId _0, IN int8_t * _1, guint _1_size, IN uint8_t * _2, guint _2_size); + uint32_t SaveSystemReportWithUser(IN nn::account::Uid _0, IN nn::ApplicationId _1, IN int8_t * _2, guint _2_size, IN uint8_t * _3, guint _3_size); + uint32_t SetUserAgreementCheckEnabled(IN bool _0); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::prepo::detail::ipc::IPrepoService::ClearStorage() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::prepo::detail::ipc::IPrepoService::GetStorageUsage(OUT int64_t& _0, OUT int64_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::prepo::detail::ipc::IPrepoService::GetTransmissionStatus(OUT int32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::prepo::detail::ipc::IPrepoService::IsUserAgreementCheckEnabled(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::prepo::detail::ipc::IPrepoService::RequestImmediateTransmission() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::prepo::detail::ipc::IPrepoService::SaveReport(IN uint64_t _0, IN gpid _1, IN int8_t * _2, guint _2_size, IN uint8_t * _3, guint _3_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(9, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(5, 0, temp5); + ctu->cpu.readmem(temp4, temp6, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + delete[] temp6; + return ret; +} +uint32_t nn::prepo::detail::ipc::IPrepoService::SaveReportWithUser(IN nn::account::Uid _0, IN uint64_t _1, IN gpid _2, IN int8_t * _3, guint _3_size, IN uint8_t * _4, guint _4_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(9, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(5, 0, temp5); + ctu->cpu.readmem(temp4, temp6, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + delete[] temp6; + return ret; +} +uint32_t nn::prepo::detail::ipc::IPrepoService::SaveSystemReport(IN nn::ApplicationId _0, IN int8_t * _1, guint _1_size, IN uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(9, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(5, 0, temp5); + ctu->cpu.readmem(temp4, temp6, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + delete[] temp6; + return ret; +} +uint32_t nn::prepo::detail::ipc::IPrepoService::SaveSystemReportWithUser(IN nn::account::Uid _0, IN nn::ApplicationId _1, IN int8_t * _2, guint _2_size, IN uint8_t * _3, guint _3_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(9, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(5, 0, temp5); + ctu->cpu.readmem(temp4, temp6, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + delete[] temp6; + return ret; +} +uint32_t nn::prepo::detail::ipc::IPrepoService::SetUserAgreementCheckEnabled(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::psc::sf { + class IPmControl { + public: + IPmControl(); + }; + class IPmModule { + public: + IPmModule(); + uint32_t Unknown0(IN uint32_t _0, IN uint8_t * _1, guint _1_size, OUT KObject * _2); + }; + class IPmService { + public: + IPmService(); + uint32_t GetIPmModule(OUT nn::psc::sf::IPmModule * _0); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::psc::sf::IPmModule::Unknown0(IN uint32_t _0, IN uint8_t * _1, guint _1_size, OUT KObject * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + shared_ptr temp4; + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + if(temp4 != nullptr) + resp.copy(0, ctu->newHandle(temp4)); + return ret; +} +uint32_t nn::psc::sf::IPmService::GetIPmModule(OUT nn::psc::sf::IPmModule * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::psc::sf::IPmModule(resp.move_handles[0]); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::psm { + class IPsmServer { + public: + IPsmServer(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown10(); + uint32_t Unknown11(); + uint32_t Unknown12(); + uint32_t Unknown13(); + uint32_t Unknown14(); + uint32_t Unknown15(); + uint32_t Unknown16(); + uint32_t Unknown17(); + uint32_t Unknown18(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + uint32_t Unknown5(); + uint32_t Unknown6(); + uint32_t Unknown7(); + uint32_t Unknown8(); + uint32_t Unknown9(); + }; + class IPsmSession { + public: + IPsmSession(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::psm::IPsmServer::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::psm::IPsmServer::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::psm::IPsmServer::Unknown10() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::psm::IPsmServer::Unknown11() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::psm::IPsmServer::Unknown12() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::psm::IPsmServer::Unknown13() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::psm::IPsmServer::Unknown14() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::psm::IPsmServer::Unknown15() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::psm::IPsmServer::Unknown16() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::psm::IPsmServer::Unknown17() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::psm::IPsmServer::Unknown18() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::psm::IPsmServer::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::psm::IPsmServer::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::psm::IPsmServer::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::psm::IPsmServer::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::psm::IPsmServer::Unknown6() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::psm::IPsmServer::Unknown7() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::psm::IPsmServer::Unknown8() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::psm::IPsmServer::Unknown9() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::psm::IPsmSession::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::psm::IPsmSession::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::psm::IPsmSession::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::psm::IPsmSession::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::psm::IPsmSession::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::pwm { + class IChannelSession { + public: + IChannelSession(); + uint32_t Unknown0(IN uint64_t _0); + uint32_t Unknown1(OUT uint64_t& _0); + uint32_t Unknown2(IN uint32_t _0); + uint32_t Unknown3(OUT uint32_t& _0); + uint32_t Unknown4(IN uint8_t _0); + uint32_t Unknown5(OUT uint8_t& _0); + }; + class IManager { + public: + IManager(); + uint32_t Unknown0(IN uint32_t _0, OUT IUnknown * _1); + uint32_t Unknown1(IN uint32_t _0, OUT IUnknown * _1); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::pwm::IChannelSession::Unknown0(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pwm::IChannelSession::Unknown1(OUT uint64_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pwm::IChannelSession::Unknown2(IN uint32_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pwm::IChannelSession::Unknown3(OUT uint32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pwm::IChannelSession::Unknown4(IN uint8_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pwm::IChannelSession::Unknown5(OUT uint8_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::pwm::IManager::Unknown0(IN uint32_t _0, OUT IUnknown * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new IUnknown(resp.move_handles[0]); + return ret; +} +uint32_t nn::pwm::IManager::Unknown1(IN uint32_t _0, OUT IUnknown * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new IUnknown(resp.move_handles[0]); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::ro::detail { + class IDebugMonitorInterface { + public: + IDebugMonitorInterface(); + uint32_t Unknown0(); + }; + class ILdrShellInterface { + public: + ILdrShellInterface(); + uint32_t AddProcessToLaunchQueue(IN uint8_t * _0, guint _0_size, IN uint32_t size, IN nn::ncm::ApplicationId appID); + uint32_t ClearLaunchQueue(); + }; + class IRoInterface { + public: + IRoInterface(); + uint32_t Unknown0(IN uint64_t _0, IN uint64_t _1, IN uint64_t _2, IN uint64_t _3, IN uint64_t _4, IN gpid _5, OUT uint64_t& _6); + uint32_t Unknown1(IN uint64_t _0, IN uint64_t _1, IN gpid _2); + uint32_t Unknown2(IN uint64_t _0, IN uint64_t _1, IN uint64_t _2, IN gpid _3); + uint32_t Unknown3(IN uint64_t _0, IN uint64_t _1, IN gpid _2); + uint32_t Unknown4(IN uint64_t _0, IN gpid _1, IN KObject * _2); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::ro::detail::IDebugMonitorInterface::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ro::detail::ILdrShellInterface::AddProcessToLaunchQueue(IN uint8_t * _0, guint _0_size, IN uint32_t size, IN nn::ncm::ApplicationId appID) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::ro::detail::ILdrShellInterface::ClearLaunchQueue() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ro::detail::IRoInterface::Unknown0(IN uint64_t _0, IN uint64_t _1, IN uint64_t _2, IN uint64_t _3, IN uint64_t _4, IN gpid _5, OUT uint64_t& _6) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ro::detail::IRoInterface::Unknown1(IN uint64_t _0, IN uint64_t _1, IN gpid _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ro::detail::IRoInterface::Unknown2(IN uint64_t _0, IN uint64_t _1, IN uint64_t _2, IN gpid _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ro::detail::IRoInterface::Unknown3(IN uint64_t _0, IN uint64_t _1, IN gpid _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ro::detail::IRoInterface::Unknown4(IN uint64_t _0, IN gpid _1, IN KObject * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::sasbus { + class IManager { + public: + IManager(); + uint32_t Unknown0(); + }; + class ISession { + public: + ISession(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + uint32_t Unknown3(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::sasbus::IManager::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::sasbus::ISession::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::sasbus::ISession::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::sasbus::ISession::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::sasbus::ISession::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::settings { + class IFactorySettingsServer { + public: + IFactorySettingsServer(); + uint32_t GetAccelerometerOffset(OUT nn::settings::factory::AccelerometerOffset& _0); + uint32_t GetAccelerometerScale(OUT nn::settings::factory::AccelerometerScale& _0); + uint32_t GetBatteryLot(OUT nn::settings::factory::BatteryLot& _0); + uint32_t GetBluetoothBdAddress(OUT nn::settings::factory::BdAddress& _0); + uint32_t GetConfigurationId1(OUT nn::settings::factory::ConfigurationId1& _0); + uint32_t GetEciDeviceCertificate(OUT nn::settings::factory::EccB233DeviceCertificate * _0, guint _0_size); + uint32_t GetEciDeviceKey(OUT nn::settings::factory::EccB233DeviceKey& _0); + uint32_t GetEticketDeviceCertificate(OUT nn::settings::factory::Rsa2048DeviceCertificate * _0, guint _0_size); + uint32_t GetEticketDeviceKey(OUT nn::settings::factory::Rsa2048DeviceKey * _0, guint _0_size); + uint32_t GetGameCardCertificate(OUT nn::settings::factory::GameCardCertificate * _0, guint _0_size); + uint32_t GetGameCardKey(OUT nn::settings::factory::GameCardKey * _0, guint _0_size); + uint32_t GetGyroscopeOffset(OUT nn::settings::factory::GyroscopeOffset& _0); + uint32_t GetGyroscopeScale(OUT nn::settings::factory::GyroscopeScale& _0); + uint32_t GetSerialNumber(OUT nn::settings::factory::SerialNumber& _0); + uint32_t GetSpeakerParameter(OUT nn::settings::factory::SpeakerParameter& _0); + uint32_t GetSslCertificate(OUT nn::settings::factory::SslCertificate * _0, guint _0_size); + uint32_t GetSslKey(OUT nn::settings::factory::SslKey * _0, guint _0_size); + uint32_t GetWirelessLanCountryCodeCount(OUT int32_t& _0); + uint32_t GetWirelessLanCountryCodes(OUT int32_t& _0, OUT nn::settings::factory::CountryCode * _1, guint _1_size); + uint32_t GetWirelessLanMacAddress(OUT nn::settings::factory::MacAddress& _0); + uint32_t SetInitialSystemAppletProgramId(IN nn::ncm::ProgramId _0); + uint32_t SetOverlayDispProgramId(IN nn::ncm::ProgramId _0); + }; + class IFirmwareDebugSettingsServer { + public: + IFirmwareDebugSettingsServer(); + uint32_t CreateSettingsItemKeyIterator(IN nn::settings::SettingsName * _0, guint _0_size, OUT nn::settings::ISettingsItemKeyIterator * _1); + uint32_t ResetSettingsItemValue(IN nn::settings::SettingsName * _0, guint _0_size, IN nn::settings::SettingsItemKey * _1, guint _1_size); + uint32_t SetSettingsItemValue(IN nn::settings::SettingsName * _0, guint _0_size, IN nn::settings::SettingsItemKey * _1, guint _1_size, IN uint8_t * _2, guint _2_size); + }; + class ISettingsItemKeyIterator { + public: + ISettingsItemKeyIterator(); + uint32_t GetKey(OUT uint64_t& _0, OUT uint8_t * _1, guint _1_size); + uint32_t GetKeySize(OUT uint64_t& _0); + uint32_t GoNext(); + }; + class ISettingsServer { + public: + ISettingsServer(); + uint32_t GetAvailableLanguageCodeCount(OUT int32_t& _0); + uint32_t GetAvailableLanguageCodes(OUT int32_t& _0, OUT nn::settings::LanguageCode * _1, guint _1_size); + uint32_t GetLanguageCode(OUT nn::settings::LanguageCode& _0); + uint32_t GetRegionCode(OUT int32_t& _0); + }; + class ISystemSettingsServer { + public: + ISystemSettingsServer(); + uint32_t AcquireFatalDirtyFlagEventHandle(OUT KObject * _0); + uint32_t AcquireTelemetryDirtyFlagEventHandle(OUT KObject * _0); + uint32_t GetAccountNotificationSettings(OUT int32_t& _0, OUT nn::settings::system::AccountNotificationSettings * _1, guint _1_size); + uint32_t GetAccountSettings(OUT nn::settings::system::AccountSettings& _0); + uint32_t GetAudioOutputMode(IN int32_t _0, OUT int32_t& _1); + uint32_t GetAudioVolume(IN int32_t _0, OUT nn::settings::system::AudioVolume& _1); + uint32_t GetAutoUpdateEnableFlag(OUT bool& _0); + uint32_t GetAutomaticApplicationDownloadFlag(OUT bool& _0); + uint32_t GetBacklightSettings(OUT nn::settings::system::BacklightSettings& _0); + uint32_t GetBacklightSettingsEx(OUT nn::settings::system::BacklightSettingsEx& _0); + uint32_t GetBatteryLot(OUT nn::settings::system::BatteryLot& _0); + uint32_t GetBatteryPercentageFlag(OUT bool& _0); + uint32_t GetBluetoothAfhEnableFlag(OUT bool& _0); + uint32_t GetBluetoothBoostEnableFlag(OUT bool& _0); + uint32_t GetBluetoothDevicesSettings(OUT int32_t& _0, OUT nn::settings::system::BluetoothDevicesSettings * _1, guint _1_size); + uint32_t GetBluetoothEnableFlag(OUT bool& _0); + uint32_t GetColorSetId(OUT int32_t& _0); + uint32_t GetConsoleInformationUploadFlag(OUT bool& _0); + uint32_t GetDataDeletionSettings(OUT nn::settings::system::DataDeletionSettings& _0); + uint32_t GetDebugModeFlag(OUT bool& _0); + uint32_t GetDeviceNickName(OUT nn::settings::system::DeviceNickName * _0, guint _0_size); + uint32_t GetDeviceTimeZoneLocationName(OUT nn::time::LocationName& _0); + uint32_t GetEdid(OUT nn::settings::system::Edid * _0, guint _0_size); + uint32_t GetEulaVersions(OUT int32_t& _0, OUT nn::settings::system::EulaVersion * _1, guint _1_size); + uint32_t GetExternalRtcResetFlag(OUT bool& _0); + uint32_t GetExternalSteadyClockInternalOffset(OUT int64_t& _0); + uint32_t GetExternalSteadyClockSourceId(OUT nn::util::Uuid& _0); + uint32_t GetFatalDirtyFlags(OUT nn::settings::system::FatalDirtyFlag& _0); + uint32_t GetFirmwareVersion(OUT nn::settings::system::FirmwareVersion * _0, guint _0_size); + uint32_t GetFirmwareVersion2(OUT nn::settings::system::FirmwareVersion * _0, guint _0_size); + uint32_t GetHeadphoneVolumeUpdateFlag(OUT bool& _0); + uint32_t GetHeadphoneVolumeWarningCount(OUT int32_t& _0); + uint32_t GetInRepairProcessEnableFlag(OUT bool& _0); + uint32_t GetInitialLaunchSettings(OUT nn::settings::system::InitialLaunchSettings& _0); + uint32_t GetInitialSystemAppletProgramId(OUT nn::ncm::ProgramId& _0); + uint32_t GetLdnChannel(OUT int32_t& _0); + uint32_t GetLockScreenFlag(OUT bool& _0); + uint32_t GetMiiAuthorId(OUT nn::util::Uuid& _0); + uint32_t GetNetworkSettings(OUT int32_t& _0, OUT nn::settings::system::NetworkSettings * _1, guint _1_size); + uint32_t GetNetworkSystemClockContext(OUT nn::time::SystemClockContext& _0); + uint32_t GetNfcEnableFlag(OUT bool& _0); + uint32_t GetNotificationSettings(OUT nn::settings::system::NotificationSettings& _0); + uint32_t GetNxControllerSettings(OUT int32_t& _0, OUT nn::settings::system::NxControllerSettings * _1, guint _1_size); + uint32_t GetOverlayDispProgramId(OUT nn::ncm::ProgramId& _0); + uint32_t GetPrimaryAlbumStorage(OUT int32_t& _0); + uint32_t GetProductModel(OUT int32_t& _0); + uint32_t GetPtmBatteryLot(OUT nn::settings::factory::BatteryLot& _0); + uint32_t GetPtmFuelGaugeParameter(OUT nn::settings::system::PtmFuelGaugeParameter& _0); + uint32_t GetPushNotificationActivityModeOnSleep(OUT int32_t& _0); + uint32_t GetQuestFlag(OUT bool& _0); + uint32_t GetSerialNumber(OUT nn::settings::system::SerialNumber& _0); + uint32_t GetSettingsItemValue(IN nn::settings::SettingsName * _0, guint _0_size, IN nn::settings::SettingsItemKey * _1, guint _1_size, OUT uint64_t& _2, OUT uint8_t * _3, guint _3_size); + uint32_t GetSettingsItemValueSize(IN nn::settings::SettingsName * _0, guint _0_size, IN nn::settings::SettingsItemKey * _1, guint _1_size, OUT uint64_t& _2); + uint32_t GetShutdownRtcValue(OUT int64_t& _0); + uint32_t GetSleepSettings(OUT nn::settings::system::SleepSettings& _0); + uint32_t GetTelemetryDirtyFlags(OUT nn::settings::system::TelemetryDirtyFlag& _0); + uint32_t GetTvSettings(OUT nn::settings::system::TvSettings& _0); + uint32_t GetUsb30EnableFlag(OUT bool& _0); + uint32_t GetUsbFullKeyEnableFlag(OUT bool& _0); + uint32_t GetUserSystemClockContext(OUT nn::time::SystemClockContext& _0); + uint32_t GetVibrationMasterVolume(OUT float32_t& _0); + uint32_t GetWirelessCertificationFile(OUT uint64_t& _0, OUT uint8_t * _1, guint _1_size); + uint32_t GetWirelessCertificationFileSize(OUT uint64_t& _0); + uint32_t GetWirelessLanEnableFlag(OUT bool& _0); + uint32_t IsForceMuteOnHeadphoneRemoved(OUT bool& _0); + uint32_t IsUserSystemClockAutomaticCorrectionEnabled(OUT bool& _0); + uint32_t NeedsToUpdateHeadphoneVolume(IN bool _0, OUT bool& _1, OUT bool& _2, OUT int8_t& _3); + uint32_t SetAccountNotificationSettings(IN nn::settings::system::AccountNotificationSettings * _0, guint _0_size); + uint32_t SetAccountSettings(IN nn::settings::system::AccountSettings _0); + uint32_t SetAudioOutputMode(IN int32_t _0, IN int32_t _1); + uint32_t SetAudioVolume(IN nn::settings::system::AudioVolume _0, IN int32_t _1); + uint32_t SetAutoUpdateEnableFlag(IN bool _0); + uint32_t SetAutomaticApplicationDownloadFlag(IN bool _0); + uint32_t SetBacklightSettings(IN nn::settings::system::BacklightSettings _0); + uint32_t SetBacklightSettingsEx(IN nn::settings::system::BacklightSettingsEx _0); + uint32_t SetBatteryPercentageFlag(IN bool _0); + uint32_t SetBluetoothAfhEnableFlag(IN bool _0); + uint32_t SetBluetoothBoostEnableFlag(IN bool _0); + uint32_t SetBluetoothDevicesSettings(IN nn::settings::system::BluetoothDevicesSettings * _0, guint _0_size); + uint32_t SetBluetoothEnableFlag(IN bool _0); + uint32_t SetColorSetId(IN int32_t _0); + uint32_t SetConsoleInformationUploadFlag(IN bool _0); + uint32_t SetDataDeletionSettings(IN nn::settings::system::DataDeletionSettings _0); + uint32_t SetDeviceNickName(IN nn::settings::system::DeviceNickName * _0, guint _0_size); + uint32_t SetDeviceTimeZoneLocationName(IN nn::time::LocationName _0); + uint32_t SetEdid(IN nn::settings::system::Edid * _0, guint _0_size); + uint32_t SetEulaVersions(IN nn::settings::system::EulaVersion * _0, guint _0_size); + uint32_t SetExternalRtcResetFlag(IN bool _0); + uint32_t SetExternalSteadyClockInternalOffset(IN int64_t _0); + uint32_t SetExternalSteadyClockSourceId(IN nn::util::Uuid _0); + uint32_t SetForceMuteOnHeadphoneRemoved(IN bool _0); + uint32_t SetHeadphoneVolumeUpdateFlag(IN bool _0); + uint32_t SetHeadphoneVolumeWarningCount(IN int32_t _0); + uint32_t SetInRepairProcessEnableFlag(IN bool _0); + uint32_t SetInitialLaunchSettings(IN nn::settings::system::InitialLaunchSettings _0); + uint32_t SetLanguageCode(IN nn::settings::LanguageCode _0); + uint32_t SetLdnChannel(IN int32_t _0); + uint32_t SetLockScreenFlag(IN bool _0); + uint32_t SetNetworkSettings(IN nn::settings::system::NetworkSettings * _0, guint _0_size); + uint32_t SetNetworkSystemClockContext(IN nn::time::SystemClockContext _0); + uint32_t SetNfcEnableFlag(IN bool _0); + uint32_t SetNotificationSettings(IN nn::settings::system::NotificationSettings _0); + uint32_t SetNxControllerSettings(IN nn::settings::system::NxControllerSettings * _0, guint _0_size); + uint32_t SetPrimaryAlbumStorage(IN int32_t _0); + uint32_t SetPtmBatteryLot(IN nn::settings::factory::BatteryLot _0); + uint32_t SetPtmFuelGaugeParameter(IN nn::settings::system::PtmFuelGaugeParameter _0); + uint32_t SetPushNotificationActivityModeOnSleep(IN int32_t _0); + uint32_t SetQuestFlag(IN bool _0); + uint32_t SetRegionCode(IN int32_t _0); + uint32_t SetShutdownRtcValue(IN int64_t _0); + uint32_t SetSleepSettings(IN nn::settings::system::SleepSettings _0); + uint32_t SetTvSettings(IN nn::settings::system::TvSettings _0); + uint32_t SetUsb30EnableFlag(IN bool _0); + uint32_t SetUsbFullKeyEnableFlag(IN bool _0); + uint32_t SetUserSystemClockAutomaticCorrectionEnabled(IN bool _0); + uint32_t SetUserSystemClockContext(IN nn::time::SystemClockContext _0); + uint32_t SetVibrationMasterVolume(IN float32_t _0); + uint32_t SetWirelessLanEnableFlag(IN bool _0); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::settings::IFactorySettingsServer::GetAccelerometerOffset(OUT nn::settings::factory::AccelerometerOffset& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(0xc); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::IFactorySettingsServer::GetAccelerometerScale(OUT nn::settings::factory::AccelerometerScale& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(0xc); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::IFactorySettingsServer::GetBatteryLot(OUT nn::settings::factory::BatteryLot& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::IFactorySettingsServer::GetBluetoothBdAddress(OUT nn::settings::factory::BdAddress& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(0xc); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::IFactorySettingsServer::GetConfigurationId1(OUT nn::settings::factory::ConfigurationId1& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::IFactorySettingsServer::GetEciDeviceCertificate(OUT nn::settings::factory::EccB233DeviceCertificate * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x16, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::settings::IFactorySettingsServer::GetEciDeviceKey(OUT nn::settings::factory::EccB233DeviceKey& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::IFactorySettingsServer::GetEticketDeviceCertificate(OUT nn::settings::factory::Rsa2048DeviceCertificate * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x16, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::settings::IFactorySettingsServer::GetEticketDeviceKey(OUT nn::settings::factory::Rsa2048DeviceKey * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x16, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::settings::IFactorySettingsServer::GetGameCardCertificate(OUT nn::settings::factory::GameCardCertificate * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x16, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::settings::IFactorySettingsServer::GetGameCardKey(OUT nn::settings::factory::GameCardKey * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x16, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::settings::IFactorySettingsServer::GetGyroscopeOffset(OUT nn::settings::factory::GyroscopeOffset& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(0xc); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::IFactorySettingsServer::GetGyroscopeScale(OUT nn::settings::factory::GyroscopeScale& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(0xc); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::IFactorySettingsServer::GetSerialNumber(OUT nn::settings::factory::SerialNumber& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::IFactorySettingsServer::GetSpeakerParameter(OUT nn::settings::factory::SpeakerParameter& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::IFactorySettingsServer::GetSslCertificate(OUT nn::settings::factory::SslCertificate * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x16, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::settings::IFactorySettingsServer::GetSslKey(OUT nn::settings::factory::SslKey * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x16, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::settings::IFactorySettingsServer::GetWirelessLanCountryCodeCount(OUT int32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::IFactorySettingsServer::GetWirelessLanCountryCodes(OUT int32_t& _0, OUT nn::settings::factory::CountryCode * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0xa, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::settings::IFactorySettingsServer::GetWirelessLanMacAddress(OUT nn::settings::factory::MacAddress& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(0xc); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::IFactorySettingsServer::SetInitialSystemAppletProgramId(IN nn::ncm::ProgramId _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::IFactorySettingsServer::SetOverlayDispProgramId(IN nn::ncm::ProgramId _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::IFirmwareDebugSettingsServer::CreateSettingsItemKeyIterator(IN nn::settings::SettingsName * _0, guint _0_size, OUT nn::settings::ISettingsItemKeyIterator * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + _1 OMG = new nn::settings::ISettingsItemKeyIterator(resp.move_handles[0]); + return ret; +} +uint32_t nn::settings::IFirmwareDebugSettingsServer::ResetSettingsItemValue(IN nn::settings::SettingsName * _0, guint _0_size, IN nn::settings::SettingsItemKey * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(0x19, 1, temp5); + ctu->cpu.readmem(temp4, temp6, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + delete[] temp6; + return ret; +} +uint32_t nn::settings::IFirmwareDebugSettingsServer::SetSettingsItemValue(IN nn::settings::SettingsName * _0, guint _0_size, IN nn::settings::SettingsItemKey * _1, guint _1_size, IN uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(0x19, 1, temp5); + ctu->cpu.readmem(temp4, temp6, temp5); + guint temp8; + auto temp7 = req.getBuffer(5, 0, temp8); + ctu->cpu.readmem(temp7, temp9, temp8); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + delete[] temp6; + delete[] temp9; + return ret; +} +uint32_t nn::settings::ISettingsItemKeyIterator::GetKey(OUT uint64_t& _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::settings::ISettingsItemKeyIterator::GetKeySize(OUT uint64_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISettingsItemKeyIterator::GoNext() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISettingsServer::GetAvailableLanguageCodeCount(OUT int32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISettingsServer::GetAvailableLanguageCodes(OUT int32_t& _0, OUT nn::settings::LanguageCode * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0xa, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::settings::ISettingsServer::GetLanguageCode(OUT nn::settings::LanguageCode& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISettingsServer::GetRegionCode(OUT int32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::AcquireFatalDirtyFlagEventHandle(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::AcquireTelemetryDirtyFlagEventHandle(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetAccountNotificationSettings(OUT int32_t& _0, OUT nn::settings::system::AccountNotificationSettings * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetAccountSettings(OUT nn::settings::system::AccountSettings& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetAudioOutputMode(IN int32_t _0, OUT int32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetAudioVolume(IN int32_t _0, OUT nn::settings::system::AudioVolume& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetAutoUpdateEnableFlag(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetAutomaticApplicationDownloadFlag(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetBacklightSettings(OUT nn::settings::system::BacklightSettings& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetBacklightSettingsEx(OUT nn::settings::system::BacklightSettingsEx& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetBatteryLot(OUT nn::settings::system::BatteryLot& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetBatteryPercentageFlag(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetBluetoothAfhEnableFlag(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetBluetoothBoostEnableFlag(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetBluetoothDevicesSettings(OUT int32_t& _0, OUT nn::settings::system::BluetoothDevicesSettings * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetBluetoothEnableFlag(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetColorSetId(OUT int32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetConsoleInformationUploadFlag(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetDataDeletionSettings(OUT nn::settings::system::DataDeletionSettings& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetDebugModeFlag(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetDeviceNickName(OUT nn::settings::system::DeviceNickName * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x16, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetDeviceTimeZoneLocationName(OUT nn::time::LocationName& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetEdid(OUT nn::settings::system::Edid * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetEulaVersions(OUT int32_t& _0, OUT nn::settings::system::EulaVersion * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetExternalRtcResetFlag(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetExternalSteadyClockInternalOffset(OUT int64_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetExternalSteadyClockSourceId(OUT nn::util::Uuid& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetFatalDirtyFlags(OUT nn::settings::system::FatalDirtyFlag& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetFirmwareVersion(OUT nn::settings::system::FirmwareVersion * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetFirmwareVersion2(OUT nn::settings::system::FirmwareVersion * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x1a, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetHeadphoneVolumeUpdateFlag(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetHeadphoneVolumeWarningCount(OUT int32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetInRepairProcessEnableFlag(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetInitialLaunchSettings(OUT nn::settings::system::InitialLaunchSettings& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetInitialSystemAppletProgramId(OUT nn::ncm::ProgramId& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetLdnChannel(OUT int32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetLockScreenFlag(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetMiiAuthorId(OUT nn::util::Uuid& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetNetworkSettings(OUT int32_t& _0, OUT nn::settings::system::NetworkSettings * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetNetworkSystemClockContext(OUT nn::time::SystemClockContext& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetNfcEnableFlag(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetNotificationSettings(OUT nn::settings::system::NotificationSettings& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetNxControllerSettings(OUT int32_t& _0, OUT nn::settings::system::NxControllerSettings * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetOverlayDispProgramId(OUT nn::ncm::ProgramId& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetPrimaryAlbumStorage(OUT int32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetProductModel(OUT int32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetPtmBatteryLot(OUT nn::settings::factory::BatteryLot& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetPtmFuelGaugeParameter(OUT nn::settings::system::PtmFuelGaugeParameter& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetPushNotificationActivityModeOnSleep(OUT int32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetQuestFlag(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetSerialNumber(OUT nn::settings::system::SerialNumber& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetSettingsItemValue(IN nn::settings::SettingsName * _0, guint _0_size, IN nn::settings::SettingsItemKey * _1, guint _1_size, OUT uint64_t& _2, OUT uint8_t * _3, guint _3_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(0x19, 1, temp5); + ctu->cpu.readmem(temp4, temp6, temp5); + guint temp8; + auto temp7 = req.getBuffer(6, 0, temp8); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + delete[] temp6; + ctu->cpu.writemem(temp7, temp9, temp8); + delete[] temp9; + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetSettingsItemValueSize(IN nn::settings::SettingsName * _0, guint _0_size, IN nn::settings::SettingsItemKey * _1, guint _1_size, OUT uint64_t& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(0x19, 1, temp5); + ctu->cpu.readmem(temp4, temp6, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + delete[] temp6; + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetShutdownRtcValue(OUT int64_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetSleepSettings(OUT nn::settings::system::SleepSettings& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetTelemetryDirtyFlags(OUT nn::settings::system::TelemetryDirtyFlag& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetTvSettings(OUT nn::settings::system::TvSettings& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetUsb30EnableFlag(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetUsbFullKeyEnableFlag(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetUserSystemClockContext(OUT nn::time::SystemClockContext& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetVibrationMasterVolume(OUT float32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetWirelessCertificationFile(OUT uint64_t& _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetWirelessCertificationFileSize(OUT uint64_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::GetWirelessLanEnableFlag(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::IsForceMuteOnHeadphoneRemoved(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::IsUserSystemClockAutomaticCorrectionEnabled(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::NeedsToUpdateHeadphoneVolume(IN bool _0, OUT bool& _1, OUT bool& _2, OUT int8_t& _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetAccountNotificationSettings(IN nn::settings::system::AccountNotificationSettings * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetAccountSettings(IN nn::settings::system::AccountSettings _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetAudioOutputMode(IN int32_t _0, IN int32_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetAudioVolume(IN nn::settings::system::AudioVolume _0, IN int32_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetAutoUpdateEnableFlag(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetAutomaticApplicationDownloadFlag(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetBacklightSettings(IN nn::settings::system::BacklightSettings _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetBacklightSettingsEx(IN nn::settings::system::BacklightSettingsEx _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetBatteryPercentageFlag(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetBluetoothAfhEnableFlag(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetBluetoothBoostEnableFlag(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetBluetoothDevicesSettings(IN nn::settings::system::BluetoothDevicesSettings * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetBluetoothEnableFlag(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetColorSetId(IN int32_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetConsoleInformationUploadFlag(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetDataDeletionSettings(IN nn::settings::system::DataDeletionSettings _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetDeviceNickName(IN nn::settings::system::DeviceNickName * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x15, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetDeviceTimeZoneLocationName(IN nn::time::LocationName _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetEdid(IN nn::settings::system::Edid * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x19, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetEulaVersions(IN nn::settings::system::EulaVersion * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetExternalRtcResetFlag(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetExternalSteadyClockInternalOffset(IN int64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetExternalSteadyClockSourceId(IN nn::util::Uuid _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetForceMuteOnHeadphoneRemoved(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetHeadphoneVolumeUpdateFlag(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetHeadphoneVolumeWarningCount(IN int32_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetInRepairProcessEnableFlag(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetInitialLaunchSettings(IN nn::settings::system::InitialLaunchSettings _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetLanguageCode(IN nn::settings::LanguageCode _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetLdnChannel(IN int32_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetLockScreenFlag(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetNetworkSettings(IN nn::settings::system::NetworkSettings * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetNetworkSystemClockContext(IN nn::time::SystemClockContext _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetNfcEnableFlag(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetNotificationSettings(IN nn::settings::system::NotificationSettings _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetNxControllerSettings(IN nn::settings::system::NxControllerSettings * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetPrimaryAlbumStorage(IN int32_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetPtmBatteryLot(IN nn::settings::factory::BatteryLot _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetPtmFuelGaugeParameter(IN nn::settings::system::PtmFuelGaugeParameter _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetPushNotificationActivityModeOnSleep(IN int32_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetQuestFlag(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetRegionCode(IN int32_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetShutdownRtcValue(IN int64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetSleepSettings(IN nn::settings::system::SleepSettings _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetTvSettings(IN nn::settings::system::TvSettings _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetUsb30EnableFlag(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetUsbFullKeyEnableFlag(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetUserSystemClockAutomaticCorrectionEnabled(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetUserSystemClockContext(IN nn::time::SystemClockContext _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetVibrationMasterVolume(IN float32_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::settings::ISystemSettingsServer::SetWirelessLanEnableFlag(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::sm::detail { + class IManagerInterface { + public: + IManagerInterface(); + uint32_t Unknown0(IN uint64_t _0, IN uint8_t * _1, guint _1_size, IN uint8_t * _2, guint _2_size); + uint32_t Unknown1(IN uint64_t _0); + }; + class IUserInterface { + public: + IUserInterface(); + uint32_t Unknown0(IN uint64_t _0, IN gpid _1); + uint32_t Unknown1(IN uint64_t _0, OUT KObject * _1); + uint32_t Unknown2(IN uint64_t _0, IN uint8_t _1, IN uint32_t _2, OUT KObject * _3); + uint32_t Unknown3(IN uint64_t _0); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::sm::detail::IManagerInterface::Unknown0(IN uint64_t _0, IN uint8_t * _1, guint _1_size, IN uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(5, 1, temp5); + ctu->cpu.readmem(temp4, temp6, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + delete[] temp6; + return ret; +} +uint32_t nn::sm::detail::IManagerInterface::Unknown1(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::sm::detail::IUserInterface::Unknown0(IN uint64_t _0, IN gpid _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::sm::detail::IUserInterface::Unknown1(IN uint64_t _0, OUT KObject * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::sm::detail::IUserInterface::Unknown2(IN uint64_t _0, IN uint8_t _1, IN uint32_t _2, OUT KObject * _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::sm::detail::IUserInterface::Unknown3(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::socket::resolver { + class IResolver { + public: + IResolver(); + uint32_t Unknown0(IN uint32_t _0, IN uint8_t * _1, guint _1_size); + uint32_t Unknown1(IN uint32_t _0, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown2(IN uint8_t _0, IN uint32_t _1, IN uint64_t _2, IN gpid _3, IN uint8_t * _4, guint _4_size, OUT uint32_t& _5, OUT uint32_t& _6, OUT uint32_t& _7, OUT uint8_t * _8, guint _8_size); + uint32_t Unknown3(IN uint32_t _0, IN uint32_t _1, IN uint32_t _2, IN uint64_t _3, IN gpid _4, IN uint8_t * _5, guint _5_size, OUT uint32_t& _6, OUT uint32_t& _7, OUT uint32_t& _8, OUT uint8_t * _9, guint _9_size); + uint32_t Unknown4(IN uint32_t _0, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown5(IN uint32_t _0, OUT uint8_t * _1, guint _1_size); + uint32_t Unknown6(IN uint8_t _0, IN uint32_t _1, IN uint64_t _2, IN gpid _3, IN uint8_t * _4, guint _4_size, IN uint8_t * _5, guint _5_size, IN uint8_t * _6, guint _6_size, OUT uint32_t& _7, OUT uint32_t& _8, OUT uint32_t& _9, OUT uint8_t * _10, guint _10_size); + uint32_t Unknown7(IN uint32_t _0, IN uint32_t _1, IN uint64_t _2, IN gpid _3, IN uint8_t * _4, guint _4_size, OUT uint32_t& _5, OUT uint32_t& _6, OUT uint8_t * _7, guint _7_size, OUT uint8_t * _8, guint _8_size); + uint32_t Unknown8(IN uint64_t _0, IN gpid _1, OUT uint32_t& _2); + uint32_t Unknown9(IN uint32_t _0, IN uint64_t _1, IN gpid _2); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::socket::resolver::IResolver::Unknown0(IN uint32_t _0, IN uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::socket::resolver::IResolver::Unknown1(IN uint32_t _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::socket::resolver::IResolver::Unknown2(IN uint8_t _0, IN uint32_t _1, IN uint64_t _2, IN gpid _3, IN uint8_t * _4, guint _4_size, OUT uint32_t& _5, OUT uint32_t& _6, OUT uint32_t& _7, OUT uint8_t * _8, guint _8_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(6, 0, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +uint32_t nn::socket::resolver::IResolver::Unknown3(IN uint32_t _0, IN uint32_t _1, IN uint32_t _2, IN uint64_t _3, IN gpid _4, IN uint8_t * _5, guint _5_size, OUT uint32_t& _6, OUT uint32_t& _7, OUT uint32_t& _8, OUT uint8_t * _9, guint _9_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(6, 0, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +uint32_t nn::socket::resolver::IResolver::Unknown4(IN uint32_t _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::socket::resolver::IResolver::Unknown5(IN uint32_t _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::socket::resolver::IResolver::Unknown6(IN uint8_t _0, IN uint32_t _1, IN uint64_t _2, IN gpid _3, IN uint8_t * _4, guint _4_size, IN uint8_t * _5, guint _5_size, IN uint8_t * _6, guint _6_size, OUT uint32_t& _7, OUT uint32_t& _8, OUT uint32_t& _9, OUT uint8_t * _10, guint _10_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(5, 1, temp5); + ctu->cpu.readmem(temp4, temp6, temp5); + guint temp8; + auto temp7 = req.getBuffer(5, 2, temp8); + ctu->cpu.readmem(temp7, temp9, temp8); + guint temp11; + auto temp10 = req.getBuffer(6, 0, temp11); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + delete[] temp6; + delete[] temp9; + ctu->cpu.writemem(temp10, temp12, temp11); + delete[] temp12; + return ret; +} +uint32_t nn::socket::resolver::IResolver::Unknown7(IN uint32_t _0, IN uint32_t _1, IN uint64_t _2, IN gpid _3, IN uint8_t * _4, guint _4_size, OUT uint32_t& _5, OUT uint32_t& _6, OUT uint8_t * _7, guint _7_size, OUT uint8_t * _8, guint _8_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(6, 0, temp5); + guint temp8; + auto temp7 = req.getBuffer(6, 1, temp8); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + ctu->cpu.writemem(temp7, temp9, temp8); + delete[] temp9; + return ret; +} +uint32_t nn::socket::resolver::IResolver::Unknown8(IN uint64_t _0, IN gpid _1, OUT uint32_t& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::socket::resolver::IResolver::Unknown9(IN uint32_t _0, IN uint64_t _1, IN gpid _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::socket::sf { + class IClient { + public: + IClient(); + uint32_t Unknown0(IN uint8_t * _0, IN uint64_t _1, IN uint64_t _2, IN gpid _3, IN KObject * _4, OUT uint32_t& _5); + uint32_t Unknown1(IN uint64_t _0, IN gpid _1); + uint32_t Unknown10(IN uint32_t _0, IN uint32_t _1, IN uint8_t * _2, guint _2_size, OUT uint32_t& _3, OUT uint32_t& _4); + uint32_t Unknown11(IN uint32_t _0, IN uint32_t _1, IN uint8_t * _2, guint _2_size, IN uint8_t * _3, guint _3_size, OUT uint32_t& _4, OUT uint32_t& _5); + uint32_t Unknown12(IN uint32_t _0, OUT uint32_t& _1, OUT uint32_t& _2, OUT uint32_t& _3, OUT uint8_t * _4, guint _4_size); + uint32_t Unknown13(IN uint32_t _0, IN uint8_t * _1, guint _1_size, OUT uint32_t& _2, OUT uint32_t& _3); + uint32_t Unknown14(IN uint32_t _0, IN uint8_t * _1, guint _1_size, OUT uint32_t& _2, OUT uint32_t& _3); + uint32_t Unknown15(IN uint32_t _0, OUT uint32_t& _1, OUT uint32_t& _2, OUT uint32_t& _3, OUT uint8_t * _4, guint _4_size); + uint32_t Unknown16(IN uint32_t _0, OUT uint32_t& _1, OUT uint32_t& _2, OUT uint32_t& _3, OUT uint8_t * _4, guint _4_size); + uint32_t Unknown17(IN uint32_t _0, IN uint32_t _1, IN uint32_t _2, OUT uint32_t& _3, OUT uint32_t& _4, OUT uint32_t& _5, OUT uint8_t * _6, guint _6_size); + uint32_t Unknown18(IN uint32_t _0, IN uint32_t _1, OUT uint32_t& _2, OUT uint32_t& _3); + uint32_t Unknown19(IN uint32_t _0, IN uint32_t _1, IN uint32_t _2, IN uint8_t * _3, guint _3_size, IN uint8_t * _4, guint _4_size, IN uint8_t * _5, guint _5_size, IN uint8_t * _6, guint _6_size, OUT uint32_t& _7, OUT uint32_t& _8, OUT uint8_t * _9, guint _9_size, OUT uint8_t * _10, guint _10_size, OUT uint8_t * _11, guint _11_size, OUT uint8_t * _12, guint _12_size); + uint32_t Unknown2(IN uint32_t _0, IN uint32_t _1, IN uint32_t _2, OUT uint32_t& _3, OUT uint32_t& _4); + uint32_t Unknown20(IN uint32_t _0, IN uint32_t _1, IN uint32_t _2, OUT uint32_t& _3, OUT uint32_t& _4); + uint32_t Unknown21(IN uint32_t _0, IN uint32_t _1, IN uint32_t _2, IN uint8_t * _3, guint _3_size, OUT uint32_t& _4, OUT uint32_t& _5); + uint32_t Unknown22(IN uint32_t _0, IN uint32_t _1, OUT uint32_t& _2, OUT uint32_t& _3); + uint32_t Unknown23(IN uint32_t _0, OUT uint32_t& _1, OUT uint32_t& _2); + uint32_t Unknown24(IN uint32_t _0, IN uint8_t * _1, guint _1_size, OUT uint32_t& _2, OUT uint32_t& _3); + uint32_t Unknown25(IN uint32_t _0, OUT uint32_t& _1, OUT uint32_t& _2, OUT uint8_t * _3, guint _3_size); + uint32_t Unknown26(IN uint32_t _0, OUT uint32_t& _1, OUT uint32_t& _2); + uint32_t Unknown27(IN uint32_t _0, IN uint64_t _1, OUT uint32_t& _2, OUT uint32_t& _3); + uint32_t Unknown28(IN uint64_t _0, IN gpid _1, OUT uint32_t& _2, OUT uint32_t& _3, OUT uint8_t * _4, guint _4_size); + uint32_t Unknown29(IN uint32_t _0, IN uint32_t _1, IN uint32_t _2, IN uint128_t _3, OUT uint32_t& _4, OUT uint32_t& _5, OUT uint8_t * _6, guint _6_size); + uint32_t Unknown3(IN uint32_t _0, IN uint32_t _1, IN uint32_t _2, OUT uint32_t& _3, OUT uint32_t& _4); + uint32_t Unknown30(IN uint32_t _0, IN uint32_t _1, IN uint32_t _2, IN uint8_t * _3, guint _3_size, IN uint8_t * _4, guint _4_size, OUT uint32_t& _5, OUT uint32_t& _6); + uint32_t Unknown4(IN uint32_t _0, IN uint8_t * _1, guint _1_size, OUT uint32_t& _2, OUT uint32_t& _3); + uint32_t Unknown5(IN uint32_t _0, IN uint8_t * _1, IN uint8_t * _2, guint _2_size, IN uint8_t * _3, guint _3_size, IN uint8_t * _4, guint _4_size, OUT uint32_t& _5, OUT uint32_t& _6, OUT uint8_t * _7, guint _7_size, OUT uint8_t * _8, guint _8_size, OUT uint8_t * _9, guint _9_size); + uint32_t Unknown6(IN uint32_t _0, IN uint32_t _1, IN uint8_t * _2, guint _2_size, OUT uint32_t& _3, OUT uint32_t& _4, OUT uint8_t * _5, guint _5_size); + uint32_t Unknown7(IN uint8_t * _0, guint _0_size, IN uint8_t * _1, guint _1_size, OUT uint32_t& _2, OUT uint32_t& _3, OUT uint32_t& _4, OUT uint8_t * _5, guint _5_size); + uint32_t Unknown8(IN uint32_t _0, IN uint32_t _1, OUT uint32_t& _2, OUT uint32_t& _3, OUT uint8_t * _4, guint _4_size); + uint32_t Unknown9(IN uint32_t _0, IN uint32_t _1, OUT uint32_t& _2, OUT uint32_t& _3, OUT uint32_t& _4, OUT uint8_t * _5, guint _5_size, OUT uint8_t * _6, guint _6_size); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::socket::sf::IClient::Unknown0(IN uint8_t * _0, IN uint64_t _1, IN uint64_t _2, IN gpid _3, IN KObject * _4, OUT uint32_t& _5) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::socket::sf::IClient::Unknown1(IN uint64_t _0, IN gpid _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::socket::sf::IClient::Unknown10(IN uint32_t _0, IN uint32_t _1, IN uint8_t * _2, guint _2_size, OUT uint32_t& _3, OUT uint32_t& _4) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x21, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::socket::sf::IClient::Unknown11(IN uint32_t _0, IN uint32_t _1, IN uint8_t * _2, guint _2_size, IN uint8_t * _3, guint _3_size, OUT uint32_t& _4, OUT uint32_t& _5) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x21, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(0x21, 1, temp5); + ctu->cpu.readmem(temp4, temp6, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + delete[] temp6; + return ret; +} +uint32_t nn::socket::sf::IClient::Unknown12(IN uint32_t _0, OUT uint32_t& _1, OUT uint32_t& _2, OUT uint32_t& _3, OUT uint8_t * _4, guint _4_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x22, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::socket::sf::IClient::Unknown13(IN uint32_t _0, IN uint8_t * _1, guint _1_size, OUT uint32_t& _2, OUT uint32_t& _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x21, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::socket::sf::IClient::Unknown14(IN uint32_t _0, IN uint8_t * _1, guint _1_size, OUT uint32_t& _2, OUT uint32_t& _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x21, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::socket::sf::IClient::Unknown15(IN uint32_t _0, OUT uint32_t& _1, OUT uint32_t& _2, OUT uint32_t& _3, OUT uint8_t * _4, guint _4_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x22, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::socket::sf::IClient::Unknown16(IN uint32_t _0, OUT uint32_t& _1, OUT uint32_t& _2, OUT uint32_t& _3, OUT uint8_t * _4, guint _4_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x22, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::socket::sf::IClient::Unknown17(IN uint32_t _0, IN uint32_t _1, IN uint32_t _2, OUT uint32_t& _3, OUT uint32_t& _4, OUT uint32_t& _5, OUT uint8_t * _6, guint _6_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x22, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::socket::sf::IClient::Unknown18(IN uint32_t _0, IN uint32_t _1, OUT uint32_t& _2, OUT uint32_t& _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::socket::sf::IClient::Unknown19(IN uint32_t _0, IN uint32_t _1, IN uint32_t _2, IN uint8_t * _3, guint _3_size, IN uint8_t * _4, guint _4_size, IN uint8_t * _5, guint _5_size, IN uint8_t * _6, guint _6_size, OUT uint32_t& _7, OUT uint32_t& _8, OUT uint8_t * _9, guint _9_size, OUT uint8_t * _10, guint _10_size, OUT uint8_t * _11, guint _11_size, OUT uint8_t * _12, guint _12_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x21, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(0x21, 1, temp5); + ctu->cpu.readmem(temp4, temp6, temp5); + guint temp8; + auto temp7 = req.getBuffer(0x21, 2, temp8); + ctu->cpu.readmem(temp7, temp9, temp8); + guint temp11; + auto temp10 = req.getBuffer(0x21, 3, temp11); + ctu->cpu.readmem(temp10, temp12, temp11); + guint temp14; + auto temp13 = req.getBuffer(0x22, 0, temp14); + guint temp17; + auto temp16 = req.getBuffer(0x22, 1, temp17); + guint temp20; + auto temp19 = req.getBuffer(0x22, 2, temp20); + guint temp23; + auto temp22 = req.getBuffer(0x22, 3, temp23); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + delete[] temp6; + delete[] temp9; + delete[] temp12; + ctu->cpu.writemem(temp13, temp15, temp14); + delete[] temp15; + ctu->cpu.writemem(temp16, temp18, temp17); + delete[] temp18; + ctu->cpu.writemem(temp19, temp21, temp20); + delete[] temp21; + ctu->cpu.writemem(temp22, temp24, temp23); + delete[] temp24; + return ret; +} +uint32_t nn::socket::sf::IClient::Unknown2(IN uint32_t _0, IN uint32_t _1, IN uint32_t _2, OUT uint32_t& _3, OUT uint32_t& _4) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::socket::sf::IClient::Unknown20(IN uint32_t _0, IN uint32_t _1, IN uint32_t _2, OUT uint32_t& _3, OUT uint32_t& _4) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::socket::sf::IClient::Unknown21(IN uint32_t _0, IN uint32_t _1, IN uint32_t _2, IN uint8_t * _3, guint _3_size, OUT uint32_t& _4, OUT uint32_t& _5) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x21, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::socket::sf::IClient::Unknown22(IN uint32_t _0, IN uint32_t _1, OUT uint32_t& _2, OUT uint32_t& _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::socket::sf::IClient::Unknown23(IN uint32_t _0, OUT uint32_t& _1, OUT uint32_t& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::socket::sf::IClient::Unknown24(IN uint32_t _0, IN uint8_t * _1, guint _1_size, OUT uint32_t& _2, OUT uint32_t& _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x21, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::socket::sf::IClient::Unknown25(IN uint32_t _0, OUT uint32_t& _1, OUT uint32_t& _2, OUT uint8_t * _3, guint _3_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x22, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::socket::sf::IClient::Unknown26(IN uint32_t _0, OUT uint32_t& _1, OUT uint32_t& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::socket::sf::IClient::Unknown27(IN uint32_t _0, IN uint64_t _1, OUT uint32_t& _2, OUT uint32_t& _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::socket::sf::IClient::Unknown28(IN uint64_t _0, IN gpid _1, OUT uint32_t& _2, OUT uint32_t& _3, OUT uint8_t * _4, guint _4_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x22, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::socket::sf::IClient::Unknown29(IN uint32_t _0, IN uint32_t _1, IN uint32_t _2, IN uint128_t _3, OUT uint32_t& _4, OUT uint32_t& _5, OUT uint8_t * _6, guint _6_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x22, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::socket::sf::IClient::Unknown3(IN uint32_t _0, IN uint32_t _1, IN uint32_t _2, OUT uint32_t& _3, OUT uint32_t& _4) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::socket::sf::IClient::Unknown30(IN uint32_t _0, IN uint32_t _1, IN uint32_t _2, IN uint8_t * _3, guint _3_size, IN uint8_t * _4, guint _4_size, OUT uint32_t& _5, OUT uint32_t& _6) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x21, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(0x21, 1, temp5); + ctu->cpu.readmem(temp4, temp6, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + delete[] temp6; + return ret; +} +uint32_t nn::socket::sf::IClient::Unknown4(IN uint32_t _0, IN uint8_t * _1, guint _1_size, OUT uint32_t& _2, OUT uint32_t& _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x21, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::socket::sf::IClient::Unknown5(IN uint32_t _0, IN uint8_t * _1, IN uint8_t * _2, guint _2_size, IN uint8_t * _3, guint _3_size, IN uint8_t * _4, guint _4_size, OUT uint32_t& _5, OUT uint32_t& _6, OUT uint8_t * _7, guint _7_size, OUT uint8_t * _8, guint _8_size, OUT uint8_t * _9, guint _9_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x21, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(0x21, 1, temp5); + ctu->cpu.readmem(temp4, temp6, temp5); + guint temp8; + auto temp7 = req.getBuffer(0x21, 2, temp8); + ctu->cpu.readmem(temp7, temp9, temp8); + guint temp11; + auto temp10 = req.getBuffer(0x22, 0, temp11); + guint temp14; + auto temp13 = req.getBuffer(0x22, 1, temp14); + guint temp17; + auto temp16 = req.getBuffer(0x22, 2, temp17); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + delete[] temp6; + delete[] temp9; + ctu->cpu.writemem(temp10, temp12, temp11); + delete[] temp12; + ctu->cpu.writemem(temp13, temp15, temp14); + delete[] temp15; + ctu->cpu.writemem(temp16, temp18, temp17); + delete[] temp18; + return ret; +} +uint32_t nn::socket::sf::IClient::Unknown6(IN uint32_t _0, IN uint32_t _1, IN uint8_t * _2, guint _2_size, OUT uint32_t& _3, OUT uint32_t& _4, OUT uint8_t * _5, guint _5_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x21, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(0x22, 0, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +uint32_t nn::socket::sf::IClient::Unknown7(IN uint8_t * _0, guint _0_size, IN uint8_t * _1, guint _1_size, OUT uint32_t& _2, OUT uint32_t& _3, OUT uint32_t& _4, OUT uint8_t * _5, guint _5_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x21, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(0x21, 1, temp5); + ctu->cpu.readmem(temp4, temp6, temp5); + guint temp8; + auto temp7 = req.getBuffer(0x22, 0, temp8); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + delete[] temp6; + ctu->cpu.writemem(temp7, temp9, temp8); + delete[] temp9; + return ret; +} +uint32_t nn::socket::sf::IClient::Unknown8(IN uint32_t _0, IN uint32_t _1, OUT uint32_t& _2, OUT uint32_t& _3, OUT uint8_t * _4, guint _4_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x22, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::socket::sf::IClient::Unknown9(IN uint32_t _0, IN uint32_t _1, OUT uint32_t& _2, OUT uint32_t& _3, OUT uint32_t& _4, OUT uint8_t * _5, guint _5_size, OUT uint8_t * _6, guint _6_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x22, 0, temp2); + guint temp5; + auto temp4 = req.getBuffer(0x22, 1, temp5); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::spl::detail { + class IRandomInterface { + public: + IRandomInterface(); + uint32_t Unknown0(OUT uint8_t * _0, guint _0_size); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::spl::detail::IRandomInterface::Unknown0(OUT uint8_t * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::spsm::detail { + class IPowerStateInterface { + public: + IPowerStateInterface(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown10(); + uint32_t Unknown11(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + uint32_t Unknown5(); + uint32_t Unknown6(); + uint32_t Unknown7(); + uint32_t Unknown8(); + uint32_t Unknown9(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::spsm::detail::IPowerStateInterface::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::spsm::detail::IPowerStateInterface::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::spsm::detail::IPowerStateInterface::Unknown10() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::spsm::detail::IPowerStateInterface::Unknown11() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::spsm::detail::IPowerStateInterface::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::spsm::detail::IPowerStateInterface::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::spsm::detail::IPowerStateInterface::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::spsm::detail::IPowerStateInterface::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::spsm::detail::IPowerStateInterface::Unknown6() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::spsm::detail::IPowerStateInterface::Unknown7() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::spsm::detail::IPowerStateInterface::Unknown8() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::spsm::detail::IPowerStateInterface::Unknown9() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::ssl::sf { + class ISslConnection { + public: + ISslConnection(); + uint32_t DoHandshake(); + uint32_t DoHandshakeGetServerCert(OUT uint32_t& _0, OUT uint32_t& _1, OUT uint8_t * _2, guint _2_size); + uint32_t FlushSessionCache(); + uint32_t GetHostName(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size); + uint32_t GetIoMode(OUT nn::ssl::sf::IoMode& _0); + uint32_t GetNeededServerCertBufferSize(OUT uint32_t& _0); + uint32_t GetOption(IN nn::ssl::sf::OptionType _0, OUT bool& _1); + uint32_t GetRenegotiationMode(OUT nn::ssl::sf::RenegotiationMode& _0); + uint32_t GetSessionCacheMode(OUT nn::ssl::sf::SessionCacheMode& _0); + uint32_t GetSocketDescriptor(OUT int32_t& _0); + uint32_t GetVerifyCertError(); + uint32_t GetVerifyCertErrors(OUT uint32_t& _0, OUT uint32_t& _1, OUT uint8_t * _2, guint _2_size); + uint32_t GetVerifyOption(OUT nn::ssl::sf::VerifyOption& _0); + uint32_t Peek(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size); + uint32_t Pending(OUT int32_t& _0); + uint32_t Poll(IN nn::ssl::sf::PollEvent _0, IN uint32_t _1, OUT nn::ssl::sf::PollEvent& _2); + uint32_t Read(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size); + uint32_t SetHostName(IN uint8_t * _0, guint _0_size); + uint32_t SetIoMode(IN nn::ssl::sf::IoMode _0); + uint32_t SetOption(IN bool _0, IN nn::ssl::sf::OptionType _1); + uint32_t SetRenegotiationMode(IN nn::ssl::sf::RenegotiationMode _0); + uint32_t SetSessionCacheMode(IN nn::ssl::sf::SessionCacheMode _0); + uint32_t SetSocketDescriptor(IN int32_t _0, OUT int32_t& _1); + uint32_t SetVerifyOption(IN nn::ssl::sf::VerifyOption _0); + uint32_t Write(IN uint8_t * _0, guint _0_size, OUT uint32_t& _1); + }; + class ISslContext { + public: + ISslContext(); + uint32_t AddPolicyOid(IN uint8_t * _0, guint _0_size); + uint32_t CreateConnection(OUT nn::ssl::sf::ISslConnection * _0); + uint32_t GetConnectionCount(OUT uint32_t& _0); + uint32_t GetOption(IN nn::ssl::sf::ContextOption _0, OUT int32_t& _1); + uint32_t ImportClientPki(IN uint8_t * _0, guint _0_size, IN uint8_t * _1, guint _1_size, OUT uint64_t& _2); + uint32_t ImportCrl(IN uint8_t * _0, guint _0_size, OUT uint64_t& _1); + uint32_t ImportServerPki(IN nn::ssl::sf::CertificateFormat _0, IN uint8_t * _1, guint _1_size, OUT uint64_t& _2); + uint32_t RegisterInternalPki(IN nn::ssl::sf::InternalPki _0, OUT uint64_t& _1); + uint32_t RemoveClientPki(IN uint64_t _0); + uint32_t RemoveCrl(IN uint64_t _0); + uint32_t RemoveServerPki(IN uint64_t _0); + uint32_t SetOption(IN nn::ssl::sf::ContextOption _0, IN int32_t _1); + }; + class ISslService { + public: + ISslService(); + uint32_t CreateContext(IN nn::ssl::sf::SslVersion _0, IN uint64_t _1, IN gpid _2, OUT nn::ssl::sf::ISslContext * _3); + uint32_t DebugIoctl(IN uint64_t _0, IN uint8_t * _1, guint _1_size, OUT uint8_t * _2, guint _2_size); + uint32_t GetCertificateBufSize(IN uint8_t * _0, guint _0_size, OUT uint32_t& _1); + uint32_t GetCertificates(IN uint8_t * _0, guint _0_size, OUT uint32_t& _1, OUT uint8_t * _2, guint _2_size); + uint32_t GetContextCount(OUT uint32_t& _0); + uint32_t SetInterfaceVersion(IN uint32_t _0); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::ssl::sf::ISslConnection::DoHandshake() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ssl::sf::ISslConnection::DoHandshakeGetServerCert(OUT uint32_t& _0, OUT uint32_t& _1, OUT uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::ssl::sf::ISslConnection::FlushSessionCache() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ssl::sf::ISslConnection::GetHostName(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::ssl::sf::ISslConnection::GetIoMode(OUT nn::ssl::sf::IoMode& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ssl::sf::ISslConnection::GetNeededServerCertBufferSize(OUT uint32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ssl::sf::ISslConnection::GetOption(IN nn::ssl::sf::OptionType _0, OUT bool& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ssl::sf::ISslConnection::GetRenegotiationMode(OUT nn::ssl::sf::RenegotiationMode& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ssl::sf::ISslConnection::GetSessionCacheMode(OUT nn::ssl::sf::SessionCacheMode& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ssl::sf::ISslConnection::GetSocketDescriptor(OUT int32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ssl::sf::ISslConnection::GetVerifyCertError() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ssl::sf::ISslConnection::GetVerifyCertErrors(OUT uint32_t& _0, OUT uint32_t& _1, OUT uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::ssl::sf::ISslConnection::GetVerifyOption(OUT nn::ssl::sf::VerifyOption& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ssl::sf::ISslConnection::Peek(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::ssl::sf::ISslConnection::Pending(OUT int32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ssl::sf::ISslConnection::Poll(IN nn::ssl::sf::PollEvent _0, IN uint32_t _1, OUT nn::ssl::sf::PollEvent& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ssl::sf::ISslConnection::Read(OUT uint32_t& _0, OUT uint8_t * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::ssl::sf::ISslConnection::SetHostName(IN uint8_t * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::ssl::sf::ISslConnection::SetIoMode(IN nn::ssl::sf::IoMode _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ssl::sf::ISslConnection::SetOption(IN bool _0, IN nn::ssl::sf::OptionType _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ssl::sf::ISslConnection::SetRenegotiationMode(IN nn::ssl::sf::RenegotiationMode _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ssl::sf::ISslConnection::SetSessionCacheMode(IN nn::ssl::sf::SessionCacheMode _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ssl::sf::ISslConnection::SetSocketDescriptor(IN int32_t _0, OUT int32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ssl::sf::ISslConnection::SetVerifyOption(IN nn::ssl::sf::VerifyOption _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ssl::sf::ISslConnection::Write(IN uint8_t * _0, guint _0_size, OUT uint32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::ssl::sf::ISslContext::AddPolicyOid(IN uint8_t * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::ssl::sf::ISslContext::CreateConnection(OUT nn::ssl::sf::ISslConnection * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::ssl::sf::ISslConnection(resp.move_handles[0]); + return ret; +} +uint32_t nn::ssl::sf::ISslContext::GetConnectionCount(OUT uint32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ssl::sf::ISslContext::GetOption(IN nn::ssl::sf::ContextOption _0, OUT int32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ssl::sf::ISslContext::ImportClientPki(IN uint8_t * _0, guint _0_size, IN uint8_t * _1, guint _1_size, OUT uint64_t& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(5, 1, temp5); + ctu->cpu.readmem(temp4, temp6, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + delete[] temp6; + return ret; +} +uint32_t nn::ssl::sf::ISslContext::ImportCrl(IN uint8_t * _0, guint _0_size, OUT uint64_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::ssl::sf::ISslContext::ImportServerPki(IN nn::ssl::sf::CertificateFormat _0, IN uint8_t * _1, guint _1_size, OUT uint64_t& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::ssl::sf::ISslContext::RegisterInternalPki(IN nn::ssl::sf::InternalPki _0, OUT uint64_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ssl::sf::ISslContext::RemoveClientPki(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ssl::sf::ISslContext::RemoveCrl(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ssl::sf::ISslContext::RemoveServerPki(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ssl::sf::ISslContext::SetOption(IN nn::ssl::sf::ContextOption _0, IN int32_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ssl::sf::ISslService::CreateContext(IN nn::ssl::sf::SslVersion _0, IN uint64_t _1, IN gpid _2, OUT nn::ssl::sf::ISslContext * _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _3 OMG = new nn::ssl::sf::ISslContext(resp.move_handles[0]); + return ret; +} +uint32_t nn::ssl::sf::ISslService::DebugIoctl(IN uint64_t _0, IN uint8_t * _1, guint _1_size, OUT uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(6, 0, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +uint32_t nn::ssl::sf::ISslService::GetCertificateBufSize(IN uint8_t * _0, guint _0_size, OUT uint32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::ssl::sf::ISslService::GetCertificates(IN uint8_t * _0, guint _0_size, OUT uint32_t& _1, OUT uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(6, 0, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +uint32_t nn::ssl::sf::ISslService::GetContextCount(OUT uint32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ssl::sf::ISslService::SetInterfaceVersion(IN uint32_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::tc { + class IManager { + public: + IManager(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + uint32_t Unknown5(); + uint32_t Unknown6(); + uint32_t Unknown7(); + uint32_t Unknown8(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::tc::IManager::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::tc::IManager::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::tc::IManager::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::tc::IManager::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::tc::IManager::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::tc::IManager::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::tc::IManager::Unknown6() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::tc::IManager::Unknown7() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::tc::IManager::Unknown8() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::timesrv::detail::service { + class IStaticService { + public: + IStaticService(); + uint32_t GetStandardLocalSystemClock(OUT nn::timesrv::detail::service::ISystemClock * _0); + uint32_t GetStandardNetworkSystemClock(OUT nn::timesrv::detail::service::ISystemClock * _0); + uint32_t GetStandardSteadyClock(OUT nn::timesrv::detail::service::ISteadyClock * _0); + uint32_t GetStandardUserSystemClock(OUT nn::timesrv::detail::service::ISystemClock * _0); + uint32_t GetTimeZoneService(OUT nn::timesrv::detail::service::ITimeZoneService * _0); + uint32_t IsStandardNetworkSystemClockAccuracySufficient(OUT bool& _0); + uint32_t IsStandardUserSystemClockAutomaticCorrectionEnabled(OUT bool& _0); + uint32_t SetStandardUserSystemClockAutomaticCorrectionEnabled(IN bool _0); + }; + class ISteadyClock { + public: + ISteadyClock(); + uint32_t GetCurrentTimePoint(OUT nn::time::SteadyClockTimePoint& _0); + uint32_t GetInternalOffset(OUT nn::TimeSpanType& _0); + uint32_t GetRtcValue(OUT int64_t& _0); + uint32_t GetSetupResutltValue(OUT uint32_t& _0); + uint32_t GetTestOffset(OUT nn::TimeSpanType& _0); + uint32_t IsRtcResetDetected(OUT bool& _0); + uint32_t SetInternalOffset(IN nn::TimeSpanType _0); + uint32_t SetTestOffset(IN nn::TimeSpanType _0); + }; + class ISystemClock { + public: + ISystemClock(); + uint32_t GetCurrentTime(OUT nn::time::PosixTime& _0); + uint32_t GetSystemClockContext(OUT nn::time::SystemClockContext& _0); + uint32_t SetCurrentTime(IN nn::time::PosixTime _0); + uint32_t SetSystemClockContext(IN nn::time::SystemClockContext _0); + }; + class ITimeZoneService { + public: + ITimeZoneService(); + uint32_t GetDeviceLocationName(OUT nn::time::LocationName& _0); + uint32_t GetTimeZoneRuleVersion(OUT nn::time::TimeZoneRuleVersion& _0); + uint32_t GetTotalLocationNameCount(OUT int32_t& _0); + uint32_t LoadLocationNameList(IN int32_t _0, OUT int32_t& _1, OUT nn::time::LocationName * _2, guint _2_size); + uint32_t LoadTimeZoneRule(IN nn::time::LocationName _0, OUT nn::time::TimeZoneRule * _1, guint _1_size); + uint32_t SetDeviceLocationName(IN nn::time::LocationName _0); + uint32_t ToCalendarTime(IN nn::time::PosixTime _0, IN nn::time::TimeZoneRule * _1, guint _1_size, OUT nn::time::CalendarTime& _2, OUT nn::time::sf::CalendarAdditionalInfo& _3); + uint32_t ToCalendarTimeWithMyRule(IN nn::time::PosixTime _0, OUT nn::time::CalendarTime& _1, OUT nn::time::sf::CalendarAdditionalInfo& _2); + uint32_t ToPosixTime(IN nn::time::CalendarTime _0, IN nn::time::TimeZoneRule * _1, guint _1_size, OUT int32_t& _2, OUT nn::time::PosixTime * _3, guint _3_size); + uint32_t ToPosixTimeWithMyRule(IN nn::time::CalendarTime _0, OUT int32_t& _1, OUT nn::time::PosixTime * _2, guint _2_size); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::timesrv::detail::service::IStaticService::GetStandardLocalSystemClock(OUT nn::timesrv::detail::service::ISystemClock * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::timesrv::detail::service::ISystemClock(resp.move_handles[0]); + return ret; +} +uint32_t nn::timesrv::detail::service::IStaticService::GetStandardNetworkSystemClock(OUT nn::timesrv::detail::service::ISystemClock * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::timesrv::detail::service::ISystemClock(resp.move_handles[0]); + return ret; +} +uint32_t nn::timesrv::detail::service::IStaticService::GetStandardSteadyClock(OUT nn::timesrv::detail::service::ISteadyClock * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::timesrv::detail::service::ISteadyClock(resp.move_handles[0]); + return ret; +} +uint32_t nn::timesrv::detail::service::IStaticService::GetStandardUserSystemClock(OUT nn::timesrv::detail::service::ISystemClock * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::timesrv::detail::service::ISystemClock(resp.move_handles[0]); + return ret; +} +uint32_t nn::timesrv::detail::service::IStaticService::GetTimeZoneService(OUT nn::timesrv::detail::service::ITimeZoneService * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::timesrv::detail::service::ITimeZoneService(resp.move_handles[0]); + return ret; +} +uint32_t nn::timesrv::detail::service::IStaticService::IsStandardNetworkSystemClockAccuracySufficient(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::timesrv::detail::service::IStaticService::IsStandardUserSystemClockAutomaticCorrectionEnabled(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::timesrv::detail::service::IStaticService::SetStandardUserSystemClockAutomaticCorrectionEnabled(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::timesrv::detail::service::ISteadyClock::GetCurrentTimePoint(OUT nn::time::SteadyClockTimePoint& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::timesrv::detail::service::ISteadyClock::GetInternalOffset(OUT nn::TimeSpanType& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::timesrv::detail::service::ISteadyClock::GetRtcValue(OUT int64_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::timesrv::detail::service::ISteadyClock::GetSetupResutltValue(OUT uint32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::timesrv::detail::service::ISteadyClock::GetTestOffset(OUT nn::TimeSpanType& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::timesrv::detail::service::ISteadyClock::IsRtcResetDetected(OUT bool& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::timesrv::detail::service::ISteadyClock::SetInternalOffset(IN nn::TimeSpanType _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::timesrv::detail::service::ISteadyClock::SetTestOffset(IN nn::TimeSpanType _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::timesrv::detail::service::ISystemClock::GetCurrentTime(OUT nn::time::PosixTime& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::timesrv::detail::service::ISystemClock::GetSystemClockContext(OUT nn::time::SystemClockContext& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::timesrv::detail::service::ISystemClock::SetCurrentTime(IN nn::time::PosixTime _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::timesrv::detail::service::ISystemClock::SetSystemClockContext(IN nn::time::SystemClockContext _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::timesrv::detail::service::ITimeZoneService::GetDeviceLocationName(OUT nn::time::LocationName& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::timesrv::detail::service::ITimeZoneService::GetTimeZoneRuleVersion(OUT nn::time::TimeZoneRuleVersion& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::timesrv::detail::service::ITimeZoneService::GetTotalLocationNameCount(OUT int32_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::timesrv::detail::service::ITimeZoneService::LoadLocationNameList(IN int32_t _0, OUT int32_t& _1, OUT nn::time::LocationName * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::timesrv::detail::service::ITimeZoneService::LoadTimeZoneRule(IN nn::time::LocationName _0, OUT nn::time::TimeZoneRule * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x16, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::timesrv::detail::service::ITimeZoneService::SetDeviceLocationName(IN nn::time::LocationName _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::timesrv::detail::service::ITimeZoneService::ToCalendarTime(IN nn::time::PosixTime _0, IN nn::time::TimeZoneRule * _1, guint _1_size, OUT nn::time::CalendarTime& _2, OUT nn::time::sf::CalendarAdditionalInfo& _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x15, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto temp4 = resp.getDataPointer(0x10); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::timesrv::detail::service::ITimeZoneService::ToCalendarTimeWithMyRule(IN nn::time::PosixTime _0, OUT nn::time::CalendarTime& _1, OUT nn::time::sf::CalendarAdditionalInfo& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(0x10); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::timesrv::detail::service::ITimeZoneService::ToPosixTime(IN nn::time::CalendarTime _0, IN nn::time::TimeZoneRule * _1, guint _1_size, OUT int32_t& _2, OUT nn::time::PosixTime * _3, guint _3_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x15, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(0xa, 0, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +uint32_t nn::timesrv::detail::service::ITimeZoneService::ToPosixTimeWithMyRule(IN nn::time::CalendarTime _0, OUT int32_t& _1, OUT nn::time::PosixTime * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0xa, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::tma { + class IHtcManager { + public: + IHtcManager(); + uint32_t Unknown0(IN uint8_t * _0, guint _0_size, OUT uint32_t& _1, OUT uint8_t * _2, guint _2_size); + uint32_t Unknown1(IN uint8_t * _0, guint _0_size, OUT uint32_t& _1); + uint32_t Unknown2(OUT KObject * _0); + uint32_t Unknown3(OUT KObject * _0); + uint32_t Unknown4(OUT KObject * _0); + uint32_t Unknown5(OUT KObject * _0); + uint32_t Unknown6(OUT uint8_t * _0, guint _0_size); + uint32_t Unknown7(OUT uint8_t * _0, guint _0_size); + uint32_t Unknown8(IN uint8_t _0); + }; + class IHtcsManager { + public: + IHtcsManager(); + uint32_t Unknown0(OUT uint32_t& _0, OUT uint32_t& _1); + uint32_t Unknown1(IN uint32_t _0, OUT uint32_t& _1, OUT uint32_t& _2); + uint32_t Unknown10(OUT uint8_t * _0); + uint32_t Unknown100(IN uint64_t _0, IN gpid _1); + uint32_t Unknown101(IN uint64_t _0, IN gpid _1); + uint32_t Unknown11(OUT uint8_t * _0); + uint32_t Unknown12(OUT uint32_t& _0, OUT IUnknown * _1); + uint32_t Unknown13(IN uint8_t _0, OUT uint32_t& _1, OUT IUnknown * _2); + uint32_t Unknown2(IN uint8_t * _0, IN uint32_t _1, OUT uint32_t& _2, OUT uint32_t& _3); + uint32_t Unknown3(IN uint8_t * _0, IN uint32_t _1, OUT uint32_t& _2, OUT uint32_t& _3); + uint32_t Unknown4(IN uint32_t _0, IN uint32_t _1, OUT uint32_t& _2, OUT uint32_t& _3); + uint32_t Unknown5(IN uint32_t _0, OUT uint8_t * _1, OUT uint32_t& _2, OUT uint32_t& _3); + uint32_t Unknown6(IN uint32_t _0, IN uint32_t _1, OUT uint32_t& _2, OUT uint64_t& _3, OUT uint8_t * _4, guint _4_size); + uint32_t Unknown7(IN uint32_t _0, IN uint32_t _1, IN uint8_t * _2, guint _2_size, OUT uint32_t& _3, OUT uint64_t& _4); + uint32_t Unknown8(IN uint32_t _0, IN uint32_t _1, OUT uint32_t& _2, OUT uint32_t& _3); + uint32_t Unknown9(IN uint32_t _0, IN uint32_t _1, IN uint32_t _2, OUT uint32_t& _3, OUT uint32_t& _4); + }; + class ISocket { + public: + ISocket(); + uint32_t Unknown0(OUT uint32_t& _0, OUT uint32_t& _1); + uint32_t Unknown1(IN uint8_t * _0, OUT uint32_t& _1, OUT uint32_t& _2); + uint32_t Unknown10(IN uint32_t _0, OUT uint8_t * _1, OUT uint32_t& _2, OUT IUnknown * _3); + uint32_t Unknown11(IN uint32_t _0, IN uint32_t _1, OUT uint32_t& _2, OUT KObject * _3); + uint32_t Unknown12(IN uint32_t _0, OUT uint32_t& _1, OUT uint64_t& _2, OUT uint8_t * _3, guint _3_size); + uint32_t Unknown13(IN uint32_t _0, IN uint32_t _1, IN uint32_t _2, IN uint64_t _3, IN KObject * _4, OUT uint32_t& _5, OUT KObject * _6); + uint32_t Unknown14(IN uint32_t _0, IN uint8_t * _1, guint _1_size, OUT uint32_t& _2, OUT KObject * _3); + uint32_t Unknown15(IN uint32_t _0, IN uint64_t _1, IN KObject * _2, IN uint8_t * _3, guint _3_size, IN uint8_t * _4, guint _4_size, OUT uint32_t& _5, OUT KObject * _6); + uint32_t Unknown16(IN uint32_t _0, OUT uint32_t& _1, OUT uint64_t& _2); + uint32_t Unknown2(IN uint8_t * _0, OUT uint32_t& _1, OUT uint32_t& _2); + uint32_t Unknown3(IN uint32_t _0, OUT uint32_t& _1, OUT uint32_t& _2); + uint32_t Unknown4(OUT uint8_t * _0, OUT uint32_t& _1, OUT IUnknown * _2); + uint32_t Unknown5(IN uint32_t _0, OUT uint32_t& _1, OUT uint64_t& _2, OUT uint8_t * _3, guint _3_size); + uint32_t Unknown6(IN uint32_t _0, IN uint8_t * _1, guint _1_size, OUT uint32_t& _2, OUT uint64_t& _3); + uint32_t Unknown7(IN uint32_t _0, OUT uint32_t& _1, OUT uint32_t& _2); + uint32_t Unknown8(IN uint32_t _0, IN uint32_t _1, OUT uint32_t& _2, OUT uint32_t& _3); + uint32_t Unknown9(OUT uint32_t& _0, OUT KObject * _1); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::tma::IHtcManager::Unknown0(IN uint8_t * _0, guint _0_size, OUT uint32_t& _1, OUT uint8_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(6, 0, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +uint32_t nn::tma::IHtcManager::Unknown1(IN uint8_t * _0, guint _0_size, OUT uint32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::tma::IHtcManager::Unknown2(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::tma::IHtcManager::Unknown3(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::tma::IHtcManager::Unknown4(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::tma::IHtcManager::Unknown5(OUT KObject * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::tma::IHtcManager::Unknown6(OUT uint8_t * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::tma::IHtcManager::Unknown7(OUT uint8_t * _0, guint _0_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::tma::IHtcManager::Unknown8(IN uint8_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::tma::IHtcsManager::Unknown0(OUT uint32_t& _0, OUT uint32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::tma::IHtcsManager::Unknown1(IN uint32_t _0, OUT uint32_t& _1, OUT uint32_t& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::tma::IHtcsManager::Unknown10(OUT uint8_t * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::tma::IHtcsManager::Unknown100(IN uint64_t _0, IN gpid _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::tma::IHtcsManager::Unknown101(IN uint64_t _0, IN gpid _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::tma::IHtcsManager::Unknown11(OUT uint8_t * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::tma::IHtcsManager::Unknown12(OUT uint32_t& _0, OUT IUnknown * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new IUnknown(resp.move_handles[0]); + return ret; +} +uint32_t nn::tma::IHtcsManager::Unknown13(IN uint8_t _0, OUT uint32_t& _1, OUT IUnknown * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _2 OMG = new IUnknown(resp.move_handles[0]); + return ret; +} +uint32_t nn::tma::IHtcsManager::Unknown2(IN uint8_t * _0, IN uint32_t _1, OUT uint32_t& _2, OUT uint32_t& _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::tma::IHtcsManager::Unknown3(IN uint8_t * _0, IN uint32_t _1, OUT uint32_t& _2, OUT uint32_t& _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::tma::IHtcsManager::Unknown4(IN uint32_t _0, IN uint32_t _1, OUT uint32_t& _2, OUT uint32_t& _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::tma::IHtcsManager::Unknown5(IN uint32_t _0, OUT uint8_t * _1, OUT uint32_t& _2, OUT uint32_t& _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::tma::IHtcsManager::Unknown6(IN uint32_t _0, IN uint32_t _1, OUT uint32_t& _2, OUT uint64_t& _3, OUT uint8_t * _4, guint _4_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::tma::IHtcsManager::Unknown7(IN uint32_t _0, IN uint32_t _1, IN uint8_t * _2, guint _2_size, OUT uint32_t& _3, OUT uint64_t& _4) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::tma::IHtcsManager::Unknown8(IN uint32_t _0, IN uint32_t _1, OUT uint32_t& _2, OUT uint32_t& _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::tma::IHtcsManager::Unknown9(IN uint32_t _0, IN uint32_t _1, IN uint32_t _2, OUT uint32_t& _3, OUT uint32_t& _4) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::tma::ISocket::Unknown0(OUT uint32_t& _0, OUT uint32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::tma::ISocket::Unknown1(IN uint8_t * _0, OUT uint32_t& _1, OUT uint32_t& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::tma::ISocket::Unknown10(IN uint32_t _0, OUT uint8_t * _1, OUT uint32_t& _2, OUT IUnknown * _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + _3 OMG = new IUnknown(resp.move_handles[0]); + return ret; +} +uint32_t nn::tma::ISocket::Unknown11(IN uint32_t _0, IN uint32_t _1, OUT uint32_t& _2, OUT KObject * _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::tma::ISocket::Unknown12(IN uint32_t _0, OUT uint32_t& _1, OUT uint64_t& _2, OUT uint8_t * _3, guint _3_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x22, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::tma::ISocket::Unknown13(IN uint32_t _0, IN uint32_t _1, IN uint32_t _2, IN uint64_t _3, IN KObject * _4, OUT uint32_t& _5, OUT KObject * _6) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::tma::ISocket::Unknown14(IN uint32_t _0, IN uint8_t * _1, guint _1_size, OUT uint32_t& _2, OUT KObject * _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x21, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + shared_ptr temp4; + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + if(temp4 != nullptr) + resp.copy(0, ctu->newHandle(temp4)); + return ret; +} +uint32_t nn::tma::ISocket::Unknown15(IN uint32_t _0, IN uint64_t _1, IN KObject * _2, IN uint8_t * _3, guint _3_size, IN uint8_t * _4, guint _4_size, OUT uint32_t& _5, OUT KObject * _6) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x21, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(0x21, 1, temp5); + ctu->cpu.readmem(temp4, temp6, temp5); + shared_ptr temp7; + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + delete[] temp6; + if(temp7 != nullptr) + resp.copy(0, ctu->newHandle(temp7)); + return ret; +} +uint32_t nn::tma::ISocket::Unknown16(IN uint32_t _0, OUT uint32_t& _1, OUT uint64_t& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::tma::ISocket::Unknown2(IN uint8_t * _0, OUT uint32_t& _1, OUT uint32_t& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::tma::ISocket::Unknown3(IN uint32_t _0, OUT uint32_t& _1, OUT uint32_t& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::tma::ISocket::Unknown4(OUT uint8_t * _0, OUT uint32_t& _1, OUT IUnknown * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto temp1 = resp.getDataPointer(8); + auto ret = ipc_send(session, &req, &resp); + _2 OMG = new IUnknown(resp.move_handles[0]); + return ret; +} +uint32_t nn::tma::ISocket::Unknown5(IN uint32_t _0, OUT uint32_t& _1, OUT uint64_t& _2, OUT uint8_t * _3, guint _3_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x22, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::tma::ISocket::Unknown6(IN uint32_t _0, IN uint8_t * _1, guint _1_size, OUT uint32_t& _2, OUT uint64_t& _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x21, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + return ret; +} +uint32_t nn::tma::ISocket::Unknown7(IN uint32_t _0, OUT uint32_t& _1, OUT uint32_t& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::tma::ISocket::Unknown8(IN uint32_t _0, IN uint32_t _1, OUT uint32_t& _2, OUT uint32_t& _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::tma::ISocket::Unknown9(OUT uint32_t& _0, OUT KObject * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::ts::server { + class IMeasurementServer { + public: + IMeasurementServer(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + uint32_t Unknown3(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::ts::server::IMeasurementServer::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ts::server::IMeasurementServer::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ts::server::IMeasurementServer::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::ts::server::IMeasurementServer::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::uart { + class IManager { + public: + IManager(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + uint32_t Unknown5(); + uint32_t Unknown6(); + uint32_t Unknown7(); + uint32_t Unknown8(); + }; + class IPortSession { + public: + IPortSession(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + uint32_t Unknown5(); + uint32_t Unknown6(); + uint32_t Unknown7(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::uart::IManager::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::uart::IManager::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::uart::IManager::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::uart::IManager::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::uart::IManager::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::uart::IManager::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::uart::IManager::Unknown6() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::uart::IManager::Unknown7() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::uart::IManager::Unknown8() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::uart::IPortSession::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::uart::IPortSession::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::uart::IPortSession::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::uart::IPortSession::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::uart::IPortSession::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::uart::IPortSession::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::uart::IPortSession::Unknown6() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::uart::IPortSession::Unknown7() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::usb::ds { + class IDsEndpoint { + public: + IDsEndpoint(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + uint32_t Unknown5(); + }; + class IDsInterface { + public: + IDsInterface(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown10(); + uint32_t Unknown11(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + uint32_t Unknown5(); + uint32_t Unknown6(); + uint32_t Unknown7(); + uint32_t Unknown8(); + uint32_t Unknown9(); + }; + class IDsService { + public: + IDsService(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + uint32_t Unknown5(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::usb::ds::IDsEndpoint::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::ds::IDsEndpoint::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::ds::IDsEndpoint::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::ds::IDsEndpoint::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::ds::IDsEndpoint::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::ds::IDsEndpoint::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::ds::IDsInterface::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::ds::IDsInterface::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::ds::IDsInterface::Unknown10() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::ds::IDsInterface::Unknown11() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::ds::IDsInterface::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::ds::IDsInterface::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::ds::IDsInterface::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::ds::IDsInterface::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::ds::IDsInterface::Unknown6() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::ds::IDsInterface::Unknown7() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::ds::IDsInterface::Unknown8() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::ds::IDsInterface::Unknown9() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::ds::IDsService::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::ds::IDsService::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::ds::IDsService::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::ds::IDsService::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::ds::IDsService::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::ds::IDsService::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::usb::hs { + class IClientEpSession { + public: + IClientEpSession(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + uint32_t Unknown5(); + uint32_t Unknown6(); + }; + class IClientIfSession { + public: + IClientIfSession(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + uint32_t Unknown5(); + uint32_t Unknown6(); + uint32_t Unknown7(); + uint32_t Unknown8(); + uint32_t Unknown9(); + }; + class IClientRootSession { + public: + IClientRootSession(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + uint32_t Unknown5(); + uint32_t Unknown6(); + uint32_t Unknown7(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::usb::hs::IClientEpSession::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::hs::IClientEpSession::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::hs::IClientEpSession::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::hs::IClientEpSession::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::hs::IClientEpSession::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::hs::IClientEpSession::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::hs::IClientEpSession::Unknown6() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::hs::IClientIfSession::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::hs::IClientIfSession::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::hs::IClientIfSession::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::hs::IClientIfSession::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::hs::IClientIfSession::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::hs::IClientIfSession::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::hs::IClientIfSession::Unknown6() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::hs::IClientIfSession::Unknown7() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::hs::IClientIfSession::Unknown8() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::hs::IClientIfSession::Unknown9() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::hs::IClientRootSession::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::hs::IClientRootSession::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::hs::IClientRootSession::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::hs::IClientRootSession::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::hs::IClientRootSession::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::hs::IClientRootSession::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::hs::IClientRootSession::Unknown6() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::hs::IClientRootSession::Unknown7() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::usb::pd::detail { + class IPdCradleManager { + public: + IPdCradleManager(); + uint32_t Unknown0(); + }; + class IPdCradleSession { + public: + IPdCradleSession(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + uint32_t Unknown5(); + uint32_t Unknown6(); + uint32_t Unknown7(); + uint32_t Unknown8(); + }; + class IPdManager { + public: + IPdManager(); + uint32_t Unknown0(); + }; + class IPdSession { + public: + IPdSession(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + uint32_t Unknown5(); + uint32_t Unknown6(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::usb::pd::detail::IPdCradleManager::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::pd::detail::IPdCradleSession::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::pd::detail::IPdCradleSession::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::pd::detail::IPdCradleSession::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::pd::detail::IPdCradleSession::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::pd::detail::IPdCradleSession::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::pd::detail::IPdCradleSession::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::pd::detail::IPdCradleSession::Unknown6() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::pd::detail::IPdCradleSession::Unknown7() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::pd::detail::IPdCradleSession::Unknown8() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::pd::detail::IPdManager::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::pd::detail::IPdSession::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::pd::detail::IPdSession::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::pd::detail::IPdSession::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::pd::detail::IPdSession::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::pd::detail::IPdSession::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::pd::detail::IPdSession::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::pd::detail::IPdSession::Unknown6() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::usb::pm { + class IPmService { + public: + IPmService(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + uint32_t Unknown5(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::usb::pm::IPmService::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::pm::IPmService::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::pm::IPmService::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::pm::IPmService::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::pm::IPmService::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::usb::pm::IPmService::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::visrv::sf { + class IApplicationDisplayService { + public: + IApplicationDisplayService(); + uint32_t CloseDisplay(IN uint64_t _0); + uint32_t CloseLayer(IN uint64_t _0); + uint32_t CreateStrayLayer(IN uint32_t _0, IN uint64_t _1, OUT uint64_t& _2, OUT int64_t& _3, OUT uint8_t * _4, guint _4_size); + uint32_t DestroyStrayLayer(IN uint64_t _0); + uint32_t GetDisplayResolution(IN uint64_t _0, OUT int64_t& _1, OUT int64_t& _2); + uint32_t GetDisplayVsyncEvent(IN uint64_t _0, OUT KObject * _1); + uint32_t GetDisplayVsyncEventForDebug(IN uint64_t _0, OUT KObject * _1); + uint32_t GetIndirectDisplayTransactionService(OUT nns::hosbinder::IHOSBinderDriver * _0); + uint32_t GetIndirectLayerImageCropMap(IN float32_t _0, IN float32_t _1, IN float32_t _2, IN float32_t _3, IN int64_t _4, IN int64_t _5, IN uint64_t _6, IN nn::applet::AppletResourceUserId _7, IN gpid _8, OUT int64_t& _9, OUT int64_t& _10, OUT uint8_t * _11, guint _11_size); + uint32_t GetIndirectLayerImageMap(IN int64_t _0, IN int64_t _1, IN uint64_t _2, IN nn::applet::AppletResourceUserId _3, IN gpid _4, OUT int64_t& _5, OUT int64_t& _6, OUT uint8_t * _7, guint _7_size); + uint32_t GetIndirectLayerImageRequiredMemoryInfo(IN int64_t _0, IN int64_t _1, OUT int64_t& _2, OUT int64_t& _3); + uint32_t GetManagerDisplayService(OUT nn::visrv::sf::IManagerDisplayService * _0); + uint32_t GetRelayService(OUT nns::hosbinder::IHOSBinderDriver * _0); + uint32_t GetSystemDisplayService(OUT nn::visrv::sf::ISystemDisplayService * _0); + uint32_t ListDisplays(OUT int64_t& _0, OUT nn::vi::DisplayInfo * _1, guint _1_size); + uint32_t OpenDefaultDisplay(OUT uint64_t& _0); + uint32_t OpenDisplay(IN nn::vi::DisplayName _0, OUT uint64_t& _1); + uint32_t OpenLayer(IN nn::vi::DisplayName _0, IN uint64_t _1, IN nn::applet::AppletResourceUserId _2, IN gpid _3, OUT int64_t& _4, OUT uint8_t * _5, guint _5_size); + uint32_t SetDisplayEnabled(IN bool _0, IN uint64_t _1); + uint32_t SetLayerScalingMode(IN uint32_t _0, IN uint64_t _1); + }; + class IApplicationRootService { + public: + IApplicationRootService(); + uint32_t GetDisplayService(IN uint32_t _0, OUT nn::visrv::sf::IApplicationDisplayService * _1); + }; + class IManagerDisplayService { + public: + IManagerDisplayService(); + uint32_t AcquireLayerTexturePresentingEvent(IN uint64_t _0, OUT KObject * _1); + uint32_t AddToLayerStack(IN uint32_t _0, IN uint64_t _1); + uint32_t CreateIndirectConsumerEndPoint(IN uint64_t _0, IN nn::applet::AppletResourceUserId _1, OUT uint64_t& _2); + uint32_t CreateIndirectLayer(OUT uint64_t& _0); + uint32_t CreateIndirectProducerEndPoint(IN uint64_t _0, IN nn::applet::AppletResourceUserId _1, OUT uint64_t& _2); + uint32_t CreateManagedLayer(IN uint32_t _0, IN uint64_t _1, IN nn::applet::AppletResourceUserId _2, OUT uint64_t& _3); + uint32_t DestroyIndirectConsumerEndPoint(IN uint64_t _0); + uint32_t DestroyIndirectLayer(IN uint64_t _0); + uint32_t DestroyIndirectProducerEndPoint(IN uint64_t _0); + uint32_t DestroyManagedLayer(IN uint64_t _0); + uint32_t GetDisplayHotplugEvent(IN uint64_t _0, OUT KObject * _1); + uint32_t GetDisplayHotplugState(IN uint64_t _0, OUT uint32_t& _1); + uint32_t GetDisplayResolution(IN uint64_t _0, OUT int64_t& _1, OUT int64_t& _2); + uint32_t ReleaseLayerTexturePresentingEvent(IN uint64_t _0); + uint32_t RemoveFromLayerStack(IN uint32_t _0, IN uint64_t _1); + uint32_t SetConductorLayer(IN bool _0, IN uint64_t _1); + uint32_t SetContentVisibility(IN bool _0); + uint32_t SetDisplayAlpha(IN float32_t _0, IN uint64_t _1); + uint32_t SetDisplayLayerStack(IN uint32_t _0, IN uint64_t _1); + uint32_t SetDisplayPowerState(IN uint32_t _0, IN uint64_t _1); + uint32_t SetIndirectProducerFlipOffset(IN uint64_t _0, IN uint64_t _1, IN nn::TimeSpan _2); + uint32_t SetLayerVisibility(IN bool _0, IN uint64_t _1); + }; + class IManagerRootService { + public: + IManagerRootService(); + uint32_t GetDisplayService(IN uint32_t _0, OUT nn::visrv::sf::IApplicationDisplayService * _1); + uint32_t GetDisplayServiceWithProxyNameExchange(IN nn::vi::ProxyName _0, IN uint32_t _1, OUT nn::visrv::sf::IApplicationDisplayService * _2); + }; + class ISystemDisplayService { + public: + ISystemDisplayService(); + uint32_t CloseIndirectLayer(IN uint64_t _0); + uint32_t CreateStrayLayer(IN uint32_t _0, IN uint64_t _1, OUT uint64_t& _2, OUT int64_t& _3, OUT uint8_t * _4, guint _4_size); + uint32_t FlipIndirectLayer(IN uint64_t _0); + uint32_t GetDisplayCmuLuma(IN uint64_t _0, OUT float32_t& _1); + uint32_t GetDisplayCmuMode(IN uint64_t _0, OUT uint32_t& _1); + uint32_t GetDisplayContentType(IN uint64_t _0, OUT uint32_t& _1); + uint32_t GetDisplayContrastRatio(IN uint64_t _0, OUT float32_t& _1); + uint32_t GetDisplayGamma(IN uint64_t _0, OUT float32_t& _1); + uint32_t GetDisplayLogicalResolution(IN uint64_t _0, OUT int32_t& _1, OUT int32_t& _2); + uint32_t GetDisplayMode(IN uint64_t _0, OUT nn::vi::DisplayModeInfo& _1); + uint32_t GetDisplayRgbRange(IN uint64_t _0, OUT uint32_t& _1); + uint32_t GetDisplayUnderscan(IN uint64_t _0, OUT int64_t& _1); + uint32_t GetLayerZ(IN uint64_t _0, OUT int64_t& _1); + uint32_t GetZOrderCountMax(IN uint64_t _0, OUT int64_t& _1); + uint32_t GetZOrderCountMin(IN uint64_t _0, OUT int64_t& _1); + uint32_t ListDisplayContentTypes(IN uint64_t _0, OUT int64_t& _1, OUT uint32_t * _2, guint _2_size); + uint32_t ListDisplayModes(IN uint64_t _0, OUT int64_t& _1, OUT nn::vi::DisplayModeInfo * _2, guint _2_size); + uint32_t ListDisplayRgbRanges(IN uint64_t _0, OUT int64_t& _1, OUT uint32_t * _2, guint _2_size); + uint32_t OpenIndirectLayer(IN uint64_t _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2, OUT int64_t& _3, OUT uint8_t * _4, guint _4_size); + uint32_t SetDisplayCmuLuma(IN float32_t _0, IN uint64_t _1); + uint32_t SetDisplayCmuMode(IN uint32_t _0, IN uint64_t _1); + uint32_t SetDisplayContentType(IN uint32_t _0, IN uint64_t _1); + uint32_t SetDisplayContrastRatio(IN float32_t _0, IN uint64_t _1); + uint32_t SetDisplayGamma(IN float32_t _0, IN uint64_t _1); + uint32_t SetDisplayMagnification(IN int32_t _0, IN int32_t _1, IN int32_t _2, IN int32_t _3, IN uint64_t _4); + uint32_t SetDisplayMode(IN uint64_t _0, IN nn::vi::DisplayModeInfo _1); + uint32_t SetDisplayRgbRange(IN uint32_t _0, IN uint64_t _1); + uint32_t SetDisplayUnderscan(IN uint64_t _0, IN int64_t _1); + uint32_t SetLayerAlpha(IN float32_t _0, IN uint64_t _1); + uint32_t SetLayerPosition(IN float32_t _0, IN float32_t _1, IN uint64_t _2); + uint32_t SetLayerSize(IN uint64_t _0, IN int64_t _1, IN int64_t _2); + uint32_t SetLayerVisibility(IN bool _0, IN uint64_t _1); + uint32_t SetLayerZ(IN uint64_t _0, IN int64_t _1); + }; + class ISystemRootService { + public: + ISystemRootService(); + uint32_t GetDisplayService(IN uint32_t _0, OUT nn::visrv::sf::IApplicationDisplayService * _1); + uint32_t GetDisplayServiceWithProxyNameExchange(IN nn::vi::ProxyName _0, IN uint32_t _1, OUT nn::visrv::sf::IApplicationDisplayService * _2); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::visrv::sf::IApplicationDisplayService::CloseDisplay(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::IApplicationDisplayService::CloseLayer(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::IApplicationDisplayService::CreateStrayLayer(IN uint32_t _0, IN uint64_t _1, OUT uint64_t& _2, OUT int64_t& _3, OUT uint8_t * _4, guint _4_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::visrv::sf::IApplicationDisplayService::DestroyStrayLayer(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::IApplicationDisplayService::GetDisplayResolution(IN uint64_t _0, OUT int64_t& _1, OUT int64_t& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::IApplicationDisplayService::GetDisplayVsyncEvent(IN uint64_t _0, OUT KObject * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::visrv::sf::IApplicationDisplayService::GetDisplayVsyncEventForDebug(IN uint64_t _0, OUT KObject * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::visrv::sf::IApplicationDisplayService::GetIndirectDisplayTransactionService(OUT nns::hosbinder::IHOSBinderDriver * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nns::hosbinder::IHOSBinderDriver(resp.move_handles[0]); + return ret; +} +uint32_t nn::visrv::sf::IApplicationDisplayService::GetIndirectLayerImageCropMap(IN float32_t _0, IN float32_t _1, IN float32_t _2, IN float32_t _3, IN int64_t _4, IN int64_t _5, IN uint64_t _6, IN nn::applet::AppletResourceUserId _7, IN gpid _8, OUT int64_t& _9, OUT int64_t& _10, OUT uint8_t * _11, guint _11_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x46, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::visrv::sf::IApplicationDisplayService::GetIndirectLayerImageMap(IN int64_t _0, IN int64_t _1, IN uint64_t _2, IN nn::applet::AppletResourceUserId _3, IN gpid _4, OUT int64_t& _5, OUT int64_t& _6, OUT uint8_t * _7, guint _7_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x46, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::visrv::sf::IApplicationDisplayService::GetIndirectLayerImageRequiredMemoryInfo(IN int64_t _0, IN int64_t _1, OUT int64_t& _2, OUT int64_t& _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::IApplicationDisplayService::GetManagerDisplayService(OUT nn::visrv::sf::IManagerDisplayService * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::visrv::sf::IManagerDisplayService(resp.move_handles[0]); + return ret; +} +uint32_t nn::visrv::sf::IApplicationDisplayService::GetRelayService(OUT nns::hosbinder::IHOSBinderDriver * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nns::hosbinder::IHOSBinderDriver(resp.move_handles[0]); + return ret; +} +uint32_t nn::visrv::sf::IApplicationDisplayService::GetSystemDisplayService(OUT nn::visrv::sf::ISystemDisplayService * _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _0 OMG = new nn::visrv::sf::ISystemDisplayService(resp.move_handles[0]); + return ret; +} +uint32_t nn::visrv::sf::IApplicationDisplayService::ListDisplays(OUT int64_t& _0, OUT nn::vi::DisplayInfo * _1, guint _1_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::visrv::sf::IApplicationDisplayService::OpenDefaultDisplay(OUT uint64_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::IApplicationDisplayService::OpenDisplay(IN nn::vi::DisplayName _0, OUT uint64_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::IApplicationDisplayService::OpenLayer(IN nn::vi::DisplayName _0, IN uint64_t _1, IN nn::applet::AppletResourceUserId _2, IN gpid _3, OUT int64_t& _4, OUT uint8_t * _5, guint _5_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::visrv::sf::IApplicationDisplayService::SetDisplayEnabled(IN bool _0, IN uint64_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::IApplicationDisplayService::SetLayerScalingMode(IN uint32_t _0, IN uint64_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::IApplicationRootService::GetDisplayService(IN uint32_t _0, OUT nn::visrv::sf::IApplicationDisplayService * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new nn::visrv::sf::IApplicationDisplayService(resp.move_handles[0]); + return ret; +} +uint32_t nn::visrv::sf::IManagerDisplayService::AcquireLayerTexturePresentingEvent(IN uint64_t _0, OUT KObject * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::visrv::sf::IManagerDisplayService::AddToLayerStack(IN uint32_t _0, IN uint64_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::IManagerDisplayService::CreateIndirectConsumerEndPoint(IN uint64_t _0, IN nn::applet::AppletResourceUserId _1, OUT uint64_t& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::IManagerDisplayService::CreateIndirectLayer(OUT uint64_t& _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::IManagerDisplayService::CreateIndirectProducerEndPoint(IN uint64_t _0, IN nn::applet::AppletResourceUserId _1, OUT uint64_t& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::IManagerDisplayService::CreateManagedLayer(IN uint32_t _0, IN uint64_t _1, IN nn::applet::AppletResourceUserId _2, OUT uint64_t& _3) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::IManagerDisplayService::DestroyIndirectConsumerEndPoint(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::IManagerDisplayService::DestroyIndirectLayer(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::IManagerDisplayService::DestroyIndirectProducerEndPoint(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::IManagerDisplayService::DestroyManagedLayer(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::IManagerDisplayService::GetDisplayHotplugEvent(IN uint64_t _0, OUT KObject * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nn::visrv::sf::IManagerDisplayService::GetDisplayHotplugState(IN uint64_t _0, OUT uint32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::IManagerDisplayService::GetDisplayResolution(IN uint64_t _0, OUT int64_t& _1, OUT int64_t& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::IManagerDisplayService::ReleaseLayerTexturePresentingEvent(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::IManagerDisplayService::RemoveFromLayerStack(IN uint32_t _0, IN uint64_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::IManagerDisplayService::SetConductorLayer(IN bool _0, IN uint64_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::IManagerDisplayService::SetContentVisibility(IN bool _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::IManagerDisplayService::SetDisplayAlpha(IN float32_t _0, IN uint64_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::IManagerDisplayService::SetDisplayLayerStack(IN uint32_t _0, IN uint64_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::IManagerDisplayService::SetDisplayPowerState(IN uint32_t _0, IN uint64_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::IManagerDisplayService::SetIndirectProducerFlipOffset(IN uint64_t _0, IN uint64_t _1, IN nn::TimeSpan _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::IManagerDisplayService::SetLayerVisibility(IN bool _0, IN uint64_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::IManagerRootService::GetDisplayService(IN uint32_t _0, OUT nn::visrv::sf::IApplicationDisplayService * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new nn::visrv::sf::IApplicationDisplayService(resp.move_handles[0]); + return ret; +} +uint32_t nn::visrv::sf::IManagerRootService::GetDisplayServiceWithProxyNameExchange(IN nn::vi::ProxyName _0, IN uint32_t _1, OUT nn::visrv::sf::IApplicationDisplayService * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _2 OMG = new nn::visrv::sf::IApplicationDisplayService(resp.move_handles[0]); + return ret; +} +uint32_t nn::visrv::sf::ISystemDisplayService::CloseIndirectLayer(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::ISystemDisplayService::CreateStrayLayer(IN uint32_t _0, IN uint64_t _1, OUT uint64_t& _2, OUT int64_t& _3, OUT uint8_t * _4, guint _4_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::visrv::sf::ISystemDisplayService::FlipIndirectLayer(IN uint64_t _0) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::ISystemDisplayService::GetDisplayCmuLuma(IN uint64_t _0, OUT float32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::ISystemDisplayService::GetDisplayCmuMode(IN uint64_t _0, OUT uint32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::ISystemDisplayService::GetDisplayContentType(IN uint64_t _0, OUT uint32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::ISystemDisplayService::GetDisplayContrastRatio(IN uint64_t _0, OUT float32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::ISystemDisplayService::GetDisplayGamma(IN uint64_t _0, OUT float32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::ISystemDisplayService::GetDisplayLogicalResolution(IN uint64_t _0, OUT int32_t& _1, OUT int32_t& _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::ISystemDisplayService::GetDisplayMode(IN uint64_t _0, OUT nn::vi::DisplayModeInfo& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::ISystemDisplayService::GetDisplayRgbRange(IN uint64_t _0, OUT uint32_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::ISystemDisplayService::GetDisplayUnderscan(IN uint64_t _0, OUT int64_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::ISystemDisplayService::GetLayerZ(IN uint64_t _0, OUT int64_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::ISystemDisplayService::GetZOrderCountMax(IN uint64_t _0, OUT int64_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::ISystemDisplayService::GetZOrderCountMin(IN uint64_t _0, OUT int64_t& _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::ISystemDisplayService::ListDisplayContentTypes(IN uint64_t _0, OUT int64_t& _1, OUT uint32_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::visrv::sf::ISystemDisplayService::ListDisplayModes(IN uint64_t _0, OUT int64_t& _1, OUT nn::vi::DisplayModeInfo * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::visrv::sf::ISystemDisplayService::ListDisplayRgbRanges(IN uint64_t _0, OUT int64_t& _1, OUT uint32_t * _2, guint _2_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::visrv::sf::ISystemDisplayService::OpenIndirectLayer(IN uint64_t _0, IN nn::applet::AppletResourceUserId _1, IN gpid _2, OUT int64_t& _3, OUT uint8_t * _4, guint _4_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(6, 0, temp2); + auto ret = ipc_send(session, &req, &resp); + ctu->cpu.writemem(temp1, temp3, temp2); + delete[] temp3; + return ret; +} +uint32_t nn::visrv::sf::ISystemDisplayService::SetDisplayCmuLuma(IN float32_t _0, IN uint64_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::ISystemDisplayService::SetDisplayCmuMode(IN uint32_t _0, IN uint64_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::ISystemDisplayService::SetDisplayContentType(IN uint32_t _0, IN uint64_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::ISystemDisplayService::SetDisplayContrastRatio(IN float32_t _0, IN uint64_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::ISystemDisplayService::SetDisplayGamma(IN float32_t _0, IN uint64_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::ISystemDisplayService::SetDisplayMagnification(IN int32_t _0, IN int32_t _1, IN int32_t _2, IN int32_t _3, IN uint64_t _4) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::ISystemDisplayService::SetDisplayMode(IN uint64_t _0, IN nn::vi::DisplayModeInfo _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::ISystemDisplayService::SetDisplayRgbRange(IN uint32_t _0, IN uint64_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::ISystemDisplayService::SetDisplayUnderscan(IN uint64_t _0, IN int64_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::ISystemDisplayService::SetLayerAlpha(IN float32_t _0, IN uint64_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::ISystemDisplayService::SetLayerPosition(IN float32_t _0, IN float32_t _1, IN uint64_t _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::ISystemDisplayService::SetLayerSize(IN uint64_t _0, IN int64_t _1, IN int64_t _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::ISystemDisplayService::SetLayerVisibility(IN bool _0, IN uint64_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::ISystemDisplayService::SetLayerZ(IN uint64_t _0, IN int64_t _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::visrv::sf::ISystemRootService::GetDisplayService(IN uint32_t _0, OUT nn::visrv::sf::IApplicationDisplayService * _1) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _1 OMG = new nn::visrv::sf::IApplicationDisplayService(resp.move_handles[0]); + return ret; +} +uint32_t nn::visrv::sf::ISystemRootService::GetDisplayServiceWithProxyNameExchange(IN nn::vi::ProxyName _0, IN uint32_t _1, OUT nn::visrv::sf::IApplicationDisplayService * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + _2 OMG = new nn::visrv::sf::IApplicationDisplayService(resp.move_handles[0]); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::wlan::detail { + class IInfraManager { + public: + IInfraManager(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown10(); + uint32_t Unknown11(); + uint32_t Unknown12(); + uint32_t Unknown13(); + uint32_t Unknown14(); + uint32_t Unknown15(); + uint32_t Unknown16(); + uint32_t Unknown17(); + uint32_t Unknown18(); + uint32_t Unknown19(); + uint32_t Unknown2(); + uint32_t Unknown20(); + uint32_t Unknown21(); + uint32_t Unknown22(); + uint32_t Unknown23(); + uint32_t Unknown24(); + uint32_t Unknown25(); + uint32_t Unknown3(); + uint32_t Unknown4(); + uint32_t Unknown5(); + uint32_t Unknown6(); + uint32_t Unknown7(); + uint32_t Unknown8(); + uint32_t Unknown9(); + }; + class ILocalGetActionFrame { + public: + ILocalGetActionFrame(); + uint32_t Unknown0(); + }; + class ILocalGetFrame { + public: + ILocalGetFrame(); + uint32_t Unknown0(); + }; + class ILocalManager { + public: + ILocalManager(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown10(); + uint32_t Unknown11(); + uint32_t Unknown12(); + uint32_t Unknown13(); + uint32_t Unknown14(); + uint32_t Unknown15(); + uint32_t Unknown16(); + uint32_t Unknown17(); + uint32_t Unknown18(); + uint32_t Unknown19(); + uint32_t Unknown2(); + uint32_t Unknown20(); + uint32_t Unknown21(); + uint32_t Unknown22(); + uint32_t Unknown23(); + uint32_t Unknown24(); + uint32_t Unknown25(); + uint32_t Unknown26(); + uint32_t Unknown27(); + uint32_t Unknown28(); + uint32_t Unknown29(); + uint32_t Unknown3(); + uint32_t Unknown30(); + uint32_t Unknown31(); + uint32_t Unknown32(); + uint32_t Unknown33(); + uint32_t Unknown34(); + uint32_t Unknown35(); + uint32_t Unknown36(); + uint32_t Unknown37(); + uint32_t Unknown38(); + uint32_t Unknown39(); + uint32_t Unknown4(); + uint32_t Unknown40(); + uint32_t Unknown41(); + uint32_t Unknown42(); + uint32_t Unknown43(); + uint32_t Unknown44(); + uint32_t Unknown5(); + uint32_t Unknown6(); + uint32_t Unknown7(); + uint32_t Unknown8(); + uint32_t Unknown9(); + }; + class ISocketGetFrame { + public: + ISocketGetFrame(); + uint32_t Unknown0(); + }; + class ISocketManager { + public: + ISocketManager(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown10(); + uint32_t Unknown11(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + uint32_t Unknown5(); + uint32_t Unknown6(); + uint32_t Unknown7(); + uint32_t Unknown8(); + uint32_t Unknown9(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::wlan::detail::IInfraManager::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::IInfraManager::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::IInfraManager::Unknown10() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::IInfraManager::Unknown11() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::IInfraManager::Unknown12() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::IInfraManager::Unknown13() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::IInfraManager::Unknown14() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::IInfraManager::Unknown15() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::IInfraManager::Unknown16() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::IInfraManager::Unknown17() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::IInfraManager::Unknown18() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::IInfraManager::Unknown19() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::IInfraManager::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::IInfraManager::Unknown20() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::IInfraManager::Unknown21() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::IInfraManager::Unknown22() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::IInfraManager::Unknown23() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::IInfraManager::Unknown24() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::IInfraManager::Unknown25() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::IInfraManager::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::IInfraManager::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::IInfraManager::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::IInfraManager::Unknown6() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::IInfraManager::Unknown7() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::IInfraManager::Unknown8() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::IInfraManager::Unknown9() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalGetActionFrame::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalGetFrame::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown10() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown11() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown12() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown13() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown14() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown15() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown16() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown17() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown18() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown19() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown20() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown21() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown22() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown23() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown24() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown25() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown26() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown27() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown28() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown29() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown30() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown31() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown32() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown33() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown34() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown35() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown36() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown37() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown38() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown39() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown40() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown41() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown42() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown43() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown44() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown6() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown7() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown8() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ILocalManager::Unknown9() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ISocketGetFrame::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ISocketManager::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ISocketManager::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ISocketManager::Unknown10() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ISocketManager::Unknown11() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ISocketManager::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ISocketManager::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ISocketManager::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ISocketManager::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ISocketManager::Unknown6() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ISocketManager::Unknown7() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ISocketManager::Unknown8() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::wlan::detail::ISocketManager::Unknown9() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nn::xcd::detail { + class ISystemServer { + public: + ISystemServer(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown10(); + uint32_t Unknown101(); + uint32_t Unknown102(); + uint32_t Unknown11(); + uint32_t Unknown12(); + uint32_t Unknown13(); + uint32_t Unknown14(); + uint32_t Unknown15(); + uint32_t Unknown16(); + uint32_t Unknown17(); + uint32_t Unknown18(); + uint32_t Unknown19(); + uint32_t Unknown2(); + uint32_t Unknown20(); + uint32_t Unknown3(); + uint32_t Unknown4(); + uint32_t Unknown5(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nn::xcd::detail::ISystemServer::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::xcd::detail::ISystemServer::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::xcd::detail::ISystemServer::Unknown10() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::xcd::detail::ISystemServer::Unknown101() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::xcd::detail::ISystemServer::Unknown102() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::xcd::detail::ISystemServer::Unknown11() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::xcd::detail::ISystemServer::Unknown12() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::xcd::detail::ISystemServer::Unknown13() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::xcd::detail::ISystemServer::Unknown14() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::xcd::detail::ISystemServer::Unknown15() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::xcd::detail::ISystemServer::Unknown16() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::xcd::detail::ISystemServer::Unknown17() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::xcd::detail::ISystemServer::Unknown18() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::xcd::detail::ISystemServer::Unknown19() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::xcd::detail::ISystemServer::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::xcd::detail::ISystemServer::Unknown20() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::xcd::detail::ISystemServer::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::xcd::detail::ISystemServer::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nn::xcd::detail::ISystemServer::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nns::hosbinder { + class IHOSBinderDriver { + public: + IHOSBinderDriver(); + uint32_t AdjustRefcount(IN int32_t _0, IN int32_t _1, IN int32_t _2); + uint32_t GetNativeHandle(IN int32_t _0, IN uint32_t _1, OUT KObject * _2); + uint32_t TransactParcel(IN int32_t _0, IN uint32_t _1, IN uint32_t _2, IN uint8_t * _3, guint _3_size, OUT uint8_t * _4, guint _4_size); + uint32_t TransactParcelAuto(IN int32_t _0, IN uint32_t _1, IN uint32_t _2, IN uint8_t * _3, guint _3_size, OUT uint8_t * _4, guint _4_size); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nns::hosbinder::IHOSBinderDriver::AdjustRefcount(IN int32_t _0, IN int32_t _1, IN int32_t _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nns::hosbinder::IHOSBinderDriver::GetNativeHandle(IN int32_t _0, IN uint32_t _1, OUT KObject * _2) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + shared_ptr temp1; + auto ret = ipc_send(session, &req, &resp); + if(temp1 != nullptr) + resp.copy(0, ctu->newHandle(temp1)); + return ret; +} +uint32_t nns::hosbinder::IHOSBinderDriver::TransactParcel(IN int32_t _0, IN uint32_t _1, IN uint32_t _2, IN uint8_t * _3, guint _3_size, OUT uint8_t * _4, guint _4_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(5, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(6, 0, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +uint32_t nns::hosbinder::IHOSBinderDriver::TransactParcelAuto(IN int32_t _0, IN uint32_t _1, IN uint32_t _2, IN uint8_t * _3, guint _3_size, OUT uint8_t * _4, guint _4_size) { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + guint temp2; + auto temp1 = req.getBuffer(0x21, 0, temp2); + ctu->cpu.readmem(temp1, temp3, temp2); + guint temp5; + auto temp4 = req.getBuffer(0x22, 0, temp5); + auto ret = ipc_send(session, &req, &resp); + delete[] temp3; + ctu->cpu.writemem(temp4, temp6, temp5); + delete[] temp6; + return ret; +} +#endif // DEFINE_CALLERS +namespace nns::nvdrv { + class INvDrvDebugFSServices { + public: + INvDrvDebugFSServices(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + }; + class INvDrvServices { + public: + INvDrvServices(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown10(); + uint32_t Unknown11(); + uint32_t Unknown12(); + uint32_t Unknown13(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + uint32_t Unknown5(); + uint32_t Unknown6(); + uint32_t Unknown7(); + uint32_t Unknown8(); + uint32_t Unknown9(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nns::nvdrv::INvDrvDebugFSServices::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nns::nvdrv::INvDrvDebugFSServices::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nns::nvdrv::INvDrvDebugFSServices::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nns::nvdrv::INvDrvDebugFSServices::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nns::nvdrv::INvDrvDebugFSServices::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nns::nvdrv::INvDrvServices::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nns::nvdrv::INvDrvServices::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nns::nvdrv::INvDrvServices::Unknown10() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nns::nvdrv::INvDrvServices::Unknown11() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nns::nvdrv::INvDrvServices::Unknown12() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nns::nvdrv::INvDrvServices::Unknown13() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nns::nvdrv::INvDrvServices::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nns::nvdrv::INvDrvServices::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nns::nvdrv::INvDrvServices::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nns::nvdrv::INvDrvServices::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nns::nvdrv::INvDrvServices::Unknown6() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nns::nvdrv::INvDrvServices::Unknown7() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nns::nvdrv::INvDrvServices::Unknown8() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nns::nvdrv::INvDrvServices::Unknown9() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nv::gemcontrol { + class INvGemControl { + public: + INvGemControl(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + uint32_t Unknown3(); + uint32_t Unknown4(); + uint32_t Unknown5(); + uint32_t Unknown6(); + uint32_t Unknown7(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nv::gemcontrol::INvGemControl::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nv::gemcontrol::INvGemControl::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nv::gemcontrol::INvGemControl::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nv::gemcontrol::INvGemControl::Unknown3() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nv::gemcontrol::INvGemControl::Unknown4() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nv::gemcontrol::INvGemControl::Unknown5() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nv::gemcontrol::INvGemControl::Unknown6() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nv::gemcontrol::INvGemControl::Unknown7() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS +namespace nv::gemcoredump { + class INvGemCoreDump { + public: + INvGemCoreDump(); + uint32_t Unknown0(); + uint32_t Unknown1(); + uint32_t Unknown2(); + }; +} +#ifdef DEFINE_CALLERS +uint32_t nv::gemcoredump::INvGemCoreDump::Unknown0() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nv::gemcoredump::INvGemCoreDump::Unknown1() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +uint32_t nv::gemcoredump::INvGemCoreDump::Unknown2() { + ipc_request_t req; + ipc_response_t resp; + memset(&req, 0, sizeof(ipc_request_t)); + auto ret = ipc_send(session, &req, &resp); + return ret; +} +#endif // DEFINE_CALLERS diff --git a/test/lib/svc.S b/test/lib/svc.S new file mode 100644 index 0000000..5d0b490 --- /dev/null +++ b/test/lib/svc.S @@ -0,0 +1,240 @@ +.align 4 + +.macro SVC_BEGIN name + .section .text.\name, "ax", %progbits + .global \name + .type \name, %function + .align 2 + .cfi_startproc +\name: +.endm + +.macro SVC_END + .cfi_endproc +.endm + +.macro DEFINE_OUT00_SVC id, name + SVC_BEGIN svc\name + svc \id + ret + SVC_END +.endm + +.macro DEFINE_OUT32_SVC id, name + SVC_BEGIN svc\name + str x0, [sp, #-0x10]! + svc \id + ldr x2, [sp] + str w1, [x2] + add sp, sp, #0x10 + ret + SVC_END +.endm + +.macro DEFINE_OUT64_SVC id, name + SVC_BEGIN svc\name + str x0, [sp, #-0x10]! + svc \id + ldr x2, [sp] + str x1, [x2] + add sp, sp, #0x10 + ret + SVC_END +.endm + +.macro DEFINE_OUT32_ARG2_SVC id, name + SVC_BEGIN svc\name + str x1, [sp, #-0x10]! + svc \id + ldr x2, [sp] + str w1, [x2] + add sp, sp, #0x10 + ret + SVC_END +.endm + +.macro DEFINE_OUT32_PAIR_SVC id, name + SVC_BEGIN svc\name + stp x0, x1, [sp, #-0x10]! + svc \id + ldr x3, [sp] + str w1, [x3] + ldr x3, [sp, #8] + str w2, [x3] + add sp, sp, #0x10 + ret + SVC_END +.endm + +DEFINE_OUT64_SVC 0x01, SetHeapSize +DEFINE_OUT00_SVC 0x02, SetMemoryPermission +DEFINE_OUT00_SVC 0x03, SetMemoryAttribute +DEFINE_OUT00_SVC 0x04, MapMemory +DEFINE_OUT00_SVC 0x05, UnmapMemory +DEFINE_OUT32_SVC 0x06, QueryMemory + +DEFINE_OUT00_SVC 0x07, ExitProcess + +DEFINE_OUT32_SVC 0x08, CreateThread +DEFINE_OUT00_SVC 0x09, StartThread +DEFINE_OUT00_SVC 0x0A, ExitThread +DEFINE_OUT00_SVC 0x0B, SleepThread +DEFINE_OUT32_SVC 0x0C, GetThreadPriority +DEFINE_OUT00_SVC 0x0D, SetThreadPriority +SVC_BEGIN svcGetThreadCoreMask + stp x0, x1, [sp, #-0x10]! + svc 0xE + ldr x3, [sp] + str w1, [x3] + ldr x3, [sp, #8] + str x2, [x3] + add sp, sp, #0x10 + ret +SVC_END +DEFINE_OUT00_SVC 0x0F, SetThreadCoreMask +DEFINE_OUT00_SVC 0x10, GetCurrentProcessorNumber + +DEFINE_OUT00_SVC 0x11, SignalEvent +DEFINE_OUT00_SVC 0x12, ClearEvent + +DEFINE_OUT00_SVC 0x13, MapSharedMemory +DEFINE_OUT00_SVC 0x14, UnmapSharedMemory +DEFINE_OUT32_SVC 0x15, CreateTransferMemory + +DEFINE_OUT00_SVC 0x16, CloseHandle + +DEFINE_OUT00_SVC 0x17, ResetSignal +DEFINE_OUT32_SVC 0x18, WaitSynchronization +DEFINE_OUT00_SVC 0x19, CancelSynchronization +DEFINE_OUT00_SVC 0x1A, ArbitrateLock +DEFINE_OUT00_SVC 0x1B, ArbitrateUnlock +DEFINE_OUT00_SVC 0x1C, WaitProcessWideKeyAtomic +DEFINE_OUT00_SVC 0x1D, SignalProcessWideKey +DEFINE_OUT00_SVC 0x1E, GetSystemTick + +DEFINE_OUT32_SVC 0x1F, ConnectToNamedPort +DEFINE_OUT00_SVC 0x20, SendSyncRequestLight +DEFINE_OUT00_SVC 0x21, SendSyncRequest +DEFINE_OUT00_SVC 0x22, SendSyncRequestWithUserBuffer +DEFINE_OUT32_SVC 0x23, SendAsyncRequestWithUserBuffer + +DEFINE_OUT64_SVC 0x24, GetProcessId +DEFINE_OUT64_SVC 0x25, GetThreadId + +DEFINE_OUT00_SVC 0x26, Break +DEFINE_OUT00_SVC 0x27, OutputDebugString +DEFINE_OUT00_SVC 0x28, ReturnFromException + +DEFINE_OUT64_SVC 0x29, GetInfo +DEFINE_OUT00_SVC 0x2A, FlushEntireDataCache +DEFINE_OUT00_SVC 0x2B, FlushDataCache + +SVC_BEGIN svcGetLastThreadInfo + str x2, [sp, #-0x10]! + stp x0, x1, [sp, #-0x10]! + svc 0x2F + ldr x7, [sp] + str x1, [x7] + str x2, [x7, #8] + str x3, [x7, #0x10] + str x4, [x7, #0x18] + ldr x7, [sp, #8] + str x5, [x7] + ldr x7, [sp, #0x10] + str w6, [x7] + add sp, sp, #0x20 + ret +SVC_END + + +DEFINE_OUT64_SVC 0x30, GetResourceLimitLimitValue +DEFINE_OUT64_SVC 0x31, GetResourceLimitCurrentValue + +DEFINE_OUT00_SVC 0x32, SetThreadActivity +DEFINE_OUT00_SVC 0x33, GetThreadContext3 + +DEFINE_OUT00_SVC 0x3C, DumpInfo + +DEFINE_OUT32_PAIR_SVC 0x40, CreateSession +DEFINE_OUT32_SVC 0x41, AcceptSession +DEFINE_OUT00_SVC 0x42, ReplyAndReceiveLight +DEFINE_OUT32_SVC 0x43, ReplyAndReceive +DEFINE_OUT32_SVC 0x44, ReplyAndReceiveWithUserBuffer +DEFINE_OUT32_PAIR_SVC 0x45, CreateEvent +DEFINE_OUT00_SVC 0x4D, SleepSystem + +DEFINE_OUT32_SVC 0x4E, ReadWriteRegister +DEFINE_OUT00_SVC 0x4F, SetProcessActivity + +DEFINE_OUT32_SVC 0x50, CreateSharedMemory +DEFINE_OUT00_SVC 0x51, MapTransferMemory +DEFINE_OUT00_SVC 0x52, UnmapTransferMemory +DEFINE_OUT32_SVC 0x53, CreateInterruptEvent +SVC_BEGIN svcQueryPhysicalAddress + str x0, [sp, #-0x10]! + svc 0x54 + ldr x4, [sp] + str x1, [x4] + str x2, [x4, #8] + str x3, [x4, #0x10] + add sp, sp, #0x10 + ret +SVC_END + +DEFINE_OUT64_SVC 0x55, QueryIoMapping +DEFINE_OUT32_SVC 0x56, CreateDeviceAddressSpace +DEFINE_OUT00_SVC 0x57, AttachDeviceAddressSpace +DEFINE_OUT00_SVC 0x58, DetachDeviceAddressSpace +DEFINE_OUT00_SVC 0x59, MapDeviceAddressSpaceByForce +DEFINE_OUT00_SVC 0x5A, MapDeviceAddressSpaceAligned +DEFINE_OUT64_SVC 0x5B, MapDeviceAddressSpace +DEFINE_OUT00_SVC 0x5C, UnmapDeviceAddressSpace +DEFINE_OUT00_SVC 0x5D, InvalidateProcessDataCache +DEFINE_OUT00_SVC 0x5E, StoreProcessDataCache +DEFINE_OUT00_SVC 0x5F, FlushProcessDataCache + +DEFINE_OUT32_SVC 0x60, DebugActiveProcess +DEFINE_OUT00_SVC 0x61, BreakDebugProcess +DEFINE_OUT00_SVC 0x62, TerminateDebugProcess +DEFINE_OUT00_SVC 0x63, GetDebugEvent +DEFINE_OUT00_SVC 0x64, ContinueDebugEvent +DEFINE_OUT32_SVC 0x65, GetProcessList +DEFINE_OUT32_SVC 0x66, GetThreadList +DEFINE_OUT00_SVC 0x67, GetDebugThreadContext +DEFINE_OUT00_SVC 0x68, SetDebugThreadContext + +DEFINE_OUT32_ARG2_SVC 0x69, QueryDebugProcessMemory +DEFINE_OUT00_SVC 0x6A, ReadDebugProcessMemory +DEFINE_OUT00_SVC 0x6B, WriteDebugProcessMemory +DEFINE_OUT00_SVC 0x6C, SetHardwareBreakPoint +SVC_BEGIN svcGetDebugThreadParam + stp x0, x1, [sp, #-0x10]! + svc 0x6D + ldr x3, [sp] + str x1, [x3] + ldr x3, [sp, #8] + str w2, [x3] + add sp, sp, #0x10 + ret +SVC_END + +DEFINE_OUT32_PAIR_SVC 0x70, CreatePort +DEFINE_OUT32_SVC 0x71, ManageNamedPort +DEFINE_OUT32_SVC 0x72, ConnectToPort + +DEFINE_OUT00_SVC 0x73, SetProcessMemoryPermission +DEFINE_OUT00_SVC 0x74, MapProcessMemory +DEFINE_OUT00_SVC 0x75, UnmapProcessMemory +DEFINE_OUT32_ARG2_SVC 0x76, QueryProcessMemory +DEFINE_OUT00_SVC 0x77, MapProcessCodeMemory +DEFINE_OUT00_SVC 0x78, UnmapProcessCodeMemory + +DEFINE_OUT32_SVC 0x79, CreateProcess +DEFINE_OUT00_SVC 0x7A, StartProcess +DEFINE_OUT00_SVC 0x7B, TerminateProcess +DEFINE_OUT64_SVC 0x7C, GetProcessInfo + +DEFINE_OUT32_SVC 0x7D, CreateResourceLimit +DEFINE_OUT00_SVC 0x7E, SetResourceLimitLimitValue + +DEFINE_OUT00_SVC 0x7F, CallSecureMonitor diff --git a/test/lib/tls.S b/test/lib/tls.S new file mode 100644 index 0000000..a8dc8a0 --- /dev/null +++ b/test/lib/tls.S @@ -0,0 +1,5 @@ + .global get_tls +get_tls: + mrs x0, tpidrro_el0 + ret + diff --git a/test/lib/util.c b/test/lib/util.c new file mode 100644 index 0000000..aea86a0 --- /dev/null +++ b/test/lib/util.c @@ -0,0 +1,104 @@ +#include +#include +#include + +char nybble2hex(u8 nybble) { + if(nybble < 10) { + return '0' + nybble; + } else { + return 'a' + (nybble - 10); + } +} + +size_t log_length = 0; +char log_buffer[0x10000]; + +int log_string(char *string, size_t len) { + svcOutputDebugString(string, len); + for(int i = 0; i < len; i++) { + if(string[i] == 0) { break; } + log_buffer[log_length++] = string[i]; + } + log_buffer[log_length++] = '\n'; + log_buffer[log_length] = 0; + return 4; +} + +void hexdump(void *rawbuf, size_t size) { + u8 *buf = rawbuf; + char line[0x31 + 4 + 0x10 + 1]; + int i = 0; + int total = 0; + while(total < size) { + i = 0; + + int linestart = total; + + // hexdump section + while(total < linestart + 0x10) { + if(total < size) { + u8 byte = buf[total++]; + line[i++] = nybble2hex(byte >> 4); + line[i++] = nybble2hex(byte & 15); + line[i++] = ' '; + } else { + line[i++] = ' '; + line[i++] = ' '; + line[i++] = ' '; + } + if(i == 3*8) { line[i++] = ' '; } + } + + line[i++] = ' '; + line[i++] = '|'; + line[i++] = ' '; + line[i++] = ' '; + + total = linestart; + + while(total < linestart + 0x10) { + if(total < size) { + u8 ch = buf[total++]; + if(ch >= ' ' && ch < 0x7F) { + line[i++] = ch; + } else { + line[i++] = '.'; + } + } else { + line[i++] = ' '; + } + } + + line[i++] = 0; + + log_string(line, sizeof(line)); + } +} + +void hexnum(int num) { + char buf[16]; + buf[15] = 0; + int i = 14; + for(; num; i--, num>>= 4) { + buf[i] = nybble2hex(num & 0xF); + } + buf[i--] = 'x'; + buf[i--] = '0'; + log_string(buf + i + 1, 16 - i); +} + +#define STB_SPRINTF_IMPLEMENTATION +#include + +#include + +int dbg_printf(char const *fmt, ...) { + va_list vl; + char buf[512]; + int ret; + va_start(vl, fmt); + ret = dbg_vsnprintf(buf, 511, fmt, vl); + log_string(buf, ret+1); + va_end(vl); + return ret; +} diff --git a/test/link.T b/test/link.T new file mode 100644 index 0000000..ccbfe6a --- /dev/null +++ b/test/link.T @@ -0,0 +1,71 @@ +OUTPUT_FORMAT(elf64-littleaarch64) + +SECTIONS +{ + .text : ALIGN(0x1000) { +NORELOC_TEXT_START_ = .; + KEEP(crt0.nso.o(.text*)) + KEEP(crt0.nro.o(.text*)) + *(.text .text*) + *(.plt .plt*) +NORELOC_TEXT_END_ = .; + } + + .rodata : ALIGN(0x1000) { +NORELOC_RODATA_START_ = .; + *(.rodata .rodata*) +NORELOC_RODATA_END_ = .; + } + + .rela.dyn : ALIGN(8) { +NORELOC_RELA_START_ = .; + *(.rela.dyn) + } + + .data : ALIGN(0x1000) { +NORELOC_DATA_START_ = .; + KEEP(crt0.nso.o(.data)) + KEEP(crt0.nro.o(.data)) + *(.data .data*) +NORELOC_GOT_START_ = .; + *(.got .got*) +NORELOC_GOT_PLT_START_ = .; + *(.got.plt .got.plt*) +NORELOC_DATA_END_ = .; + } + + .dynamic : ALIGN(0x8) { +NORELOC_DYNAMIC_START_ = .; + *(.dynamic) +NORELOC_DYNAMIC_END_ = .; + } + + .bss : ALIGN(0x1000) { +NORELOC_BSS_START_ = .; + *(.bss) + *(COMMON) +NORELOC_BSS_END_ = .; + } + + .hash : { + *(.hash) + } + + .dynstr : { +NORELOC_DYNSTR_START_ = .; + *(.dynstr .dynstr*) +NORELOC_DYNSTR_END_ = .; + } + + .dynsym : { +NORELOC_DYNSYM_START_ = .; + *(.dynsym .dynsym*) +NORELOC_DYNSYM_END_ = .; + } + + /DISCARD/ : { + *(.comment) + *(.note.GNU-stack) + *(.eh_frame) + } +} diff --git a/test/newlib b/test/newlib new file mode 160000 index 0000000..ca50741 --- /dev/null +++ b/test/newlib @@ -0,0 +1 @@ +Subproject commit ca507418b832a4828a6b8b480f22132e2dc8e22a diff --git a/test/requirements.txt b/test/requirements.txt new file mode 100644 index 0000000..7561409 --- /dev/null +++ b/test/requirements.txt @@ -0,0 +1,2 @@ +pyelftools>=0.24 +lz4>=0.10 diff --git a/test/test.txt b/test/test.txt new file mode 100644 index 0000000..2262de0 --- /dev/null +++ b/test/test.txt @@ -0,0 +1 @@ +hoge diff --git a/test/test/test_bsd.c b/test/test/test_bsd.c new file mode 100644 index 0000000..fb5e11a --- /dev/null +++ b/test/test/test_bsd.c @@ -0,0 +1,154 @@ +#include + +#include + +int main() { + svcSleepThread(100000000); + + result_t r; + if((r = sm_init()) != RESULT_OK) { + dbg_printf("failed to init sm: 0x%x", r); + return 1; + } + + if((r = bsd_init()) != RESULT_OK) { + dbg_printf("failed to init bsd: 0x%x, %d", r, bsd_errno); + goto err_only_sm; + } + + char bind_ip_addr[4] = {0, 0, 0, 0}; + char server_ip_addr[4] = {127, 0, 0, 1}; + + struct sockaddr_in bind_addr = { + .sin_family = AF_INET, + .sin_port = htons(4444), + .sin_addr = { + .s_addr = *(uint32_t*) bind_ip_addr + } + }; + + struct sockaddr_in server_addr = { + .sin_family = AF_INET, + .sin_port = htons(5555), + .sin_addr = { + .s_addr = *(uint32_t*) server_ip_addr + } + }; + + // client socket test + // socket, connect, sendto, recv, close + int cfd = bsd_socket(2, 1, 6); // AF_INET, SOCK_STREAM, PROTO_TCP + if(cfd < 0) { + dbg_printf("failed to create socket: 0x%x, %d", bsd_result, bsd_errno); + goto err; + } + + dbg_printf("made client socket %d", cfd); + + if(bsd_connect(cfd, (struct sockaddr*) &server_addr, sizeof(server_addr)) < 0) { + dbg_printf("failed to connect socket: 0x%x, %d", bsd_result, bsd_errno); + goto err; + } + + char hello[] = "Hello from libtransistor over a socket!"; + if(bsd_sendto(cfd, hello, sizeof(hello), 0, (struct sockaddr*) &server_addr, sizeof(server_addr)) < 0) { + dbg_printf("failed to sendto: 0x%x, %d", bsd_result, bsd_errno); + goto err; + } + + int num_bytes; + char response[512]; + char expected_response[] = "testing recv..."; + if((num_bytes = bsd_recv(cfd, response, sizeof(response), 0)) < 0) { + dbg_printf("failed to recv: 0x%x, %d", bsd_result, bsd_errno); + goto err; + } + response[num_bytes] = 0; + if(num_bytes != sizeof(expected_response)) { + dbg_printf("got back wrong response: %s", response); + goto err; + } + for(int i = 0; i < num_bytes; i++) { + if(response[i] != expected_response[i]) { + dbg_printf("got back wrong response: %s", response); + goto err; + } + } + + // server socket test + // socket, bind, listen, accept, send, recv, close + int sfd = bsd_socket(2, 1, 6); // AF_INET, SOCK_STREAM, PROTO_TCP + if(sfd < 0) { + dbg_printf("failed to create socket: 0x%x, %d", bsd_result, bsd_errno); + goto err; + } + + if(bsd_bind(sfd, (struct sockaddr*) &bind_addr, sizeof(bind_addr)) < 0) { + dbg_printf("failed to bind socket: 0x%x, %d", bsd_result, bsd_errno); + goto err; + } + + if(bsd_listen(sfd, 20) != 0) { + dbg_printf("failed to listen on socket: 0x%x, %d", bsd_result, bsd_errno); + goto err; + } + + // don't close client test's socket until we're all set up. + // closing the client test's socket signals to the test helper + // that we're listening. + if(bsd_close(cfd) < 0) { + dbg_printf("failed to close: 0x%x, %d", bsd_result, bsd_errno); + goto err; + } + + struct sockaddr_in remote_addr; + socklen_t remote_addr_len = sizeof(remote_addr); + + int rfd; + if((rfd = bsd_accept(sfd, (struct sockaddr*) &remote_addr, &remote_addr_len)) < 0) { + dbg_printf("failed to accept: 0x%x, %d", bsd_result, bsd_errno); + goto err; + } + + if(bsd_send(rfd, hello, sizeof(hello), 0) < 0) { + dbg_printf("failed to send: 0x%x, %d", bsd_result, bsd_errno); + goto err; + } + + if((num_bytes = bsd_recv(rfd, response, sizeof(response), 0)) < 0) { + dbg_printf("failed to recv: 0x%x, %d", bsd_result, bsd_errno); + goto err; + } + response[num_bytes] = 0; + if(num_bytes != sizeof(expected_response)) { + dbg_printf("got back wrong response: %s", response); + goto err; + } + for(int i = 0; i < num_bytes; i++) { + if(response[i] != expected_response[i]) { + dbg_printf("got back wrong response: %s", response); + goto err; + } + } + + if(bsd_close(rfd) < 0) { + dbg_printf("failed to close: 0x%x, %d", bsd_result, bsd_errno); + goto err; + } + + if(bsd_close(sfd) < 0) { + dbg_printf("failed to close: 0x%x, %d", bsd_result, bsd_errno); + goto err; + } + + bsd_finalize(); + sm_finalize(); + dbg_printf("bsd tests passed."); + return 0; + + err: + bsd_finalize(); + err_only_sm: + sm_finalize(); + return 1; +} diff --git a/test/test/test_bsd_ai_packing.c b/test/test/test_bsd_ai_packing.c new file mode 100644 index 0000000..40260cf --- /dev/null +++ b/test/test/test_bsd_ai_packing.c @@ -0,0 +1,89 @@ +#include + +#include +#include + +int main() { + result_t r; + + char ip_addr[4] = {10, 0, 0, 192}; + + struct sockaddr_in sa; + sa.sin_family = AF_INET; + sa.sin_port = htons(6767); + sa.sin_addr.s_addr = *(uint32_t*) ip_addr; + + struct addrinfo ai_udp; + struct addrinfo ai_tcp; + + ai_udp.ai_flags = 0; + ai_udp.ai_family = AF_INET; + ai_udp.ai_socktype = SOCK_DGRAM; + ai_udp.ai_protocol = IPPROTO_UDP; + ai_udp.ai_addrlen = sizeof(sa); + ai_udp.ai_addr = (struct sockaddr*) &sa; + ai_udp.ai_canonname = NULL; + ai_udp.ai_next = &ai_tcp; + + ai_tcp.ai_flags = 0; + ai_tcp.ai_family = AF_INET; + ai_tcp.ai_socktype = SOCK_STREAM; + ai_tcp.ai_protocol = IPPROTO_TCP; + ai_tcp.ai_addrlen = sizeof(sa); + ai_tcp.ai_addr = (struct sockaddr*) &sa; + ai_tcp.ai_canonname = NULL; + ai_tcp.ai_next = NULL; + + uint8_t buf[0x400]; + r = bsd_ai_pack(&ai_udp, buf, sizeof(buf)); + if(r) { + dbg_printf("failed to pack addrinfo: 0x%x", r); + return 1; + } + + uint8_t template[] = { + 0xbe, 0xef, 0xca, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, + 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x10, 0x00, 0x02, 0x6f, 0x1a, 0xc0, 0x00, 0x00, 0x0a, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xbe, 0xef, 0xca, 0xfe, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, + 0x10, 0x00, 0x02, 0x6f, 0x1a, 0xc0, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00 + }; + + for(int i = 0; i < sizeof(template); i++) { + if(buf[i] != template[i]) { + dbg_printf("packing mismatch at +0x%x", i); + hexdump(buf, 0x50); + return 1; + } + } + + dbg_printf("bsd addrinfo packing test passed"); + + struct addrinfo *out; + r = bsd_ai_unpack(&out, template, sizeof(template)); + if(r) { + dbg_printf("failed to unpack addrinfo: 0x%x", r); + return 1; + } + + if(!(memcmp(out, &ai_udp, sizeof(struct addrinfo) - sizeof(ai_udp.ai_next)))) { + dbg_printf("ai_udp does not match"); + return 1; + } + + if(out->ai_next == NULL) { + dbg_printf("only unpacked one addrinfo struct"); + return 1; + } + + if(!(memcmp(out->ai_next, &ai_tcp, sizeof(struct addrinfo)))) { + dbg_printf("ai_tcp does not match"); + return 1; + } + + bsd_freeaddrinfo(out); + + dbg_printf("bsd addrinfo unpacking test passed"); + return 0; +} diff --git a/test/test/test_malloc.c b/test/test/test_malloc.c new file mode 100644 index 0000000..301c328 --- /dev/null +++ b/test/test/test_malloc.c @@ -0,0 +1,16 @@ +#include +#include + +int main() { + svcSleepThread(100000000); + + void *buf = malloc(4); + + dbg_printf("malloc returned %p", buf); + + if(buf == NULL) { + return 1; + } + + return 0; +} diff --git a/test/test/test_sfdnsres.c b/test/test/test_sfdnsres.c new file mode 100644 index 0000000..8b7cc7c --- /dev/null +++ b/test/test/test_sfdnsres.c @@ -0,0 +1,76 @@ +#include + +#include + +void dumpsockaddrin(struct sockaddr_in *sin) { + dbg_printf("sin_family: %d", sin->sin_family); + dbg_printf("sin_port: %d", ntohs(sin->sin_port)); + uint32_t addr = sin->sin_addr.s_addr; + uint8_t *bytes = (uint8_t*) &addr; + dbg_printf("sin_addr: %d.%d.%d.%d", bytes[0], bytes[1], bytes[2], bytes[3]); +} + +void dumpaddrinfo(struct addrinfo *ai) { + dbg_printf("ai_flags: %d", ai->ai_flags); + dbg_printf("ai_family: %d", ai->ai_family); + dbg_printf("ai_socktype: %d", ai->ai_socktype); + dbg_printf("ai_protocol: %d", ai->ai_protocol); + dbg_printf("ai_addrlen: %d", ai->ai_addrlen); + if(ai->ai_family == AF_INET) { + dumpsockaddrin((struct sockaddr_in*) ai->ai_addr); + } + if(ai->ai_canonname) { + dbg_printf("ai_canonname: \"%s\"", ai->ai_canonname); + } else { + dbg_printf("ai_canonname: NULL"); + } + if(ai->ai_next) { + dbg_printf("ai_next:"); + dumpaddrinfo(ai->ai_next); + } +} + +int main() { + svcSleepThread(100000000); + + result_t r; + if((r = sm_init()) != RESULT_OK) { + dbg_printf("failed to init sm: 0x%x", r); + return 1; + } + + if((r = bsd_init()) != RESULT_OK) { + dbg_printf("failed to init bsd: 0x%x, %d", r, bsd_errno); + goto err_only_sm; + } + + struct addrinfo *ai = NULL; + + struct addrinfo hints; + hints.ai_family = AF_INET; + hints.ai_socktype = SOCK_STREAM; + + int e = bsd_getaddrinfo("conntest.nintendowifi.net", "6767", &hints, &ai); + if(e) { + dbg_printf("failed to getaddrinfo: %d, 0x%x", e, bsd_result); + goto err; + } + + if(ai == NULL) { + dbg_printf("addrinfo is null?"); + goto err; + } + + dumpaddrinfo(ai); + + bsd_finalize(); + sm_finalize(); + return 0; + + err: + bsd_finalize(); + err_only_sm: + sm_finalize(); + return 1; + +} diff --git a/test/test_helpers/bsd.rb b/test/test_helpers/bsd.rb new file mode 100644 index 0000000..74713a7 --- /dev/null +++ b/test/test_helpers/bsd.rb @@ -0,0 +1,43 @@ +require "socket" + +server = TCPServer.new(5555) + +child = fork do + exec(ARGV[0], "--load-nro", "build/test/test_bsd.nro", "--enable-sockets") +end + +client = server.accept +msg = client.recv(512) +if(msg != "Hello from libtransistor over a socket!\x00") then + Process.kill("INT", child) + raise "wrong hello message (got '#{msg}')" +end + +client.send("testing recv...\x00", 0) +puts "waiting on eof..." +if(!client.eof) then + Process.kill("INT", child) + raise "remote end didn't close socket" +end +puts "eof reached" + +client.close +server.close + +puts "connecting" +client = TCPSocket.new("127.0.0.1", 4444) +puts "connected" +msg = client.recv(512) +if(msg != "Hello from libtransistor over a socket!\x00") then + Process.kill("INT", child) + raise "wrong hello message (got '#{msg}')" +end + +client.send("testing recv...\x00", 0) +if(!client.eof) then + Process.kill("INT", child) + raise "remote end didn't close socket" +end + +Process.wait(child) +exit($?.exitstatus) diff --git a/test/tools/elf2nxo.py b/test/tools/elf2nxo.py new file mode 100644 index 0000000..da9ffdc --- /dev/null +++ b/test/tools/elf2nxo.py @@ -0,0 +1,115 @@ +#!/usr/bin/env python + +import struct, sys +from elftools.elf.elffile import ELFFile +from elftools.elf.relocation import RelocationSection +from elftools.elf.sections import * +import lz4.block + +R_AARCH64_ABS64 = 257 +R_AARCH64_ABS32 = 258 +R_AARCH64_ABS16 = 259 +R_AARCH64_PREL64 = 260 +R_AARCH64_PREL32 = 261 +R_AARCH64_PREL16 = 262 + +def main(input, output, format='nro'): + format = format.lower() + assert format in ('nro', 'nso') + + with file(input, 'rb') as f: + elffile = ELFFile(f) + elffile.iter_sections_by_type = lambda type: (x for x in elffile.iter_sections() if isinstance(x, type)) + + symbols = {} + symbolList = [] + for x in elffile.iter_sections_by_type(SymbolTableSection): + for i, sym in enumerate(x.iter_symbols()): + sectaddr = elffile.get_section(sym['st_shndx'])['sh_addr'] if isinstance(sym['st_shndx'], int) else 0 + symbols[sym.name] = sectaddr + sym['st_value'] + symbolList.append(sym.name) + + textCont, rodataCont, relaDynCont, dataCont, dynamicCont = [elffile.get_section_by_name(x).data() for x in ('.text', '.rodata', '.rela.dyn', '.data', '.dynamic')] + csec = dict(text=textCont, rodata=rodataCont, relaDyn=relaDynCont, data=dataCont, dynamic=dynamicCont) + + def replace(tgt, offset, data): + orig = csec[tgt] + csec[tgt] = orig[:offset] + data + orig[offset+len(data):] + + for x in elffile.iter_sections_by_type(RelocationSection): + tgtsect = elffile.get_section(x['sh_info']) + tgt = tgtsect.name[1:] + if tgt not in csec: + continue + for iter in x.iter_relocations(): + symname = symbolList[iter['r_info_sym']] + if not symname.startswith('NORELOC_'): + continue + + type = iter['r_info_type'] + if type == R_AARCH64_PREL32: + replace(tgt, iter['r_offset'], struct.pack(' 9 else str(x) + +typemap = dict( + i8='int8_t', + i16='int16_t', + i32='int32_t', + i64='int64_t', + i128='int128_t', + u8='uint8_t', + u16='uint16_t', + u32='uint32_t', + u64='uint64_t', + u128='uint128_t', + f32='float32_t', + pid='gpid', + bool='bool', +) + +typesizes = dict( + i8=1, + i16=2, + i32=4, + i64=8, + i128=16, + u8=1, + u16=2, + u32=4, + u64=8, + u128=16, + f32=4, + pid=8, + bool=1, +) + +allTypes = None + +def typeSize(type): + if type[0] in ('unknown', 'i8', 'u8'): + return 1 + elif type[0] == 'bytes': + return type[1] + elif type[0] in allTypes: + return typeSize(allTypes[type[0]]) + elif type[0] in typesizes: + return typesizes[type[0]] + return 1 + +def splitByNs(obj): + ons = {} + for type, x in obj.items(): + ns = type.rsplit('::', 1)[0] if '::' in type else None + name = type.rsplit('::', 1)[-1] + if ns not in ons: + ons[ns] = {} + ons[ns][name] = x + return ons + +def retype(spec, noIndex=False): + if spec[0] == 'unknown': + return 'uint8_t' + elif spec[0] == 'bytes': + return 'uint8_t%s' % ('[%s]' % emitInt(spec[1]) if not noIndex else ' *') + else: + return typemap[spec[0]] if spec[0] in typemap else spec[0]; + +def formatParam(param, input, i): + name, spec = param + if name is None: + name = '_%i' % i + + hasSize = False + + if spec[0] == 'align': + return formatParam((name, spec[2]), input, i) + + if spec[0] == 'bytes': + type = 'uint8_t *' + elif spec[0] == 'unknown': + assert False + elif spec[0] == 'buffer': + type = '%s *' % retype(spec[1]) + hasSize = True + elif spec[0] == 'array': + type = retype(spec[1]) + ' *' + hasSize = True + elif spec[0] == 'object': + type = '%s *' % spec[1][0] + elif spec[0] == 'KObject': + type = 'KObject *' + else: + type = typemap[spec[0]] if spec[0] in typemap else spec[0] + + if type.endswith(']'): + arrspec = type[type.index('['):] + type = type[:-len(arrspec)] + else: + arrspec = '' + + return '%s %s%s %s%s%s' % ('IN' if input else 'OUT', type, '&' if not input and (not type.endswith('*') and not arrspec) else '', name, arrspec, ', guint %s_size' % name if hasSize else '') + +def generatePrototype(func): + return ', '.join([formatParam(x, True, i) for i, x in enumerate(func['inputs'])] + [formatParam(x, False, i + len(func['inputs'])) for i, x in enumerate(func['outputs'])]) + +def isPointerType(type): + if type[0] in typesizes: + return False + elif type[0] == 'bytes': + return True + elif type[0] in allTypes: + return isPointerType(allTypes[type[0]]) + return True + +AFTER = 'AFTER' + +def generateCaller(qname, fname, func): + def tempname(): + tempI[0] += 1 + return 'temp%i' % tempI[0] + params = [] + logFmt, logElems = [], [] + tempI = [0] + inpOffset = 8 + bufOffs = {} + hndOff = 0 + objOff = 0 + bufSizes = 0 + for name, elem in func['inputs']: + type, rest = elem[0], elem[1:] + if type in ('array', 'buffer'): + if rest[1] not in bufOffs: + bufOffs[rest[1]] = 0 + cbo = bufOffs[rest[1]] + bufOffs[rest[1]] += 1 + an, sn, bn = tempname(), tempname(), tempname() + yield 'guint %s;' % sn + yield 'auto %s = req.getBuffer(%s, %i, %s);' % (an, emitInt(rest[1]), cbo, sn) + #yield 'auto %s = new uint8_t[%s];' % (bn, sn) + yield 'ctu->cpu.readmem(%s, %s, %s);' % (an, bn, sn) + params.append('(%s *) %s' % (retype(rest[0]), bn)) + params.append(sn) + logFmt.append('%s *%s= buffer<0x" ADDRFMT ">' % (retype(rest[0]), '%s ' % name if name else '')) + logElems.append(sn) + bufSizes += 1 + yield AFTER, 'delete[] %s;' % bn + elif type == 'object': + params.append('ctu->getHandle<%s>(req.getMoved(%i))' % (rest[0][0], objOff)) + logFmt.append('%s %s= 0x%%x' % (rest[0][0], '%s ' % name if name else '')) + logElems.append('req.getMoved(%i)' % objOff) + objOff += 1 + elif type == 'KObject': + params.append('ctu->getHandle(req.getCopied(%i))' % hndOff) + logFmt.append('KObject %s= 0x%%x' % ('%s ' % name if name else '')) + logElems.append('req.getCopied(%i)' % objOff) + hndOff += 1 + elif type == 'pid': + params.append('req.pid') + else: + if elem[0] == 'align': + alignment = elem[1] + elem = elem[2] + else: + alignment = min(8, typeSize(elem)) + while inpOffset % alignment: + inpOffset += 1 + if isPointerType(elem): + params.append('req.getDataPointer<%s>(%s)' % (retype(elem, noIndex=True), emitInt(inpOffset))) + logFmt.append('%s %s= %%s' % (retype(elem), '%s ' % name if name else '')) + logElems.append('bufferToString(req.getDataPointer(%s), %s).c_str()' % (emitInt(inpOffset), emitInt(typeSize(elem)))) + else: + params.append('req.getData<%s>(%s)' % (retype(elem), emitInt(inpOffset))) + if typeSize(elem) == 16: + logFmt.append('%s %s= %%s' % (retype(elem), '%s ' % name if name else '')) + logElems.append('bufferToString(req.getDataPointer(%s), %s).c_str()' % (emitInt(inpOffset), emitInt(typeSize(elem)))) + else: + type = retype(elem) + ct = '0x%x' + if type == 'float32_t': + ct = '%f' + elif typeSize(elem) == 8: + ct = '0x" ADDRFMT "' + logFmt.append('%s %s= %s' % (type, '%s ' % name if name else '', ct)) + logElems.append('%sreq.getData<%s>(%s)' % ('(double) ' if type == 'float32_t' else '', type, emitInt(inpOffset))) + inpOffset += typeSize(elem) + + outOffset = 8 + hndOff = 0 + objOff = 0 + for i, (name, elem) in enumerate(func['outputs']): + if name is None: + name = '_%i' % (i + len(func['inputs'])) + type, rest = elem[0], elem[1:] + if type in ('array', 'buffer'): + if rest[1] not in bufOffs: + bufOffs[rest[1]] = 0 + cbo = bufOffs[rest[1]] + bufOffs[rest[1]] += 1 + an, sn, bn = tempname(), tempname(), tempname() + yield 'guint %s;' % sn + yield 'auto %s = req.getBuffer(%s, %i, %s);' % (an, emitInt(rest[1]), cbo, sn) + #yield 'auto %s = new uint8_t[%s];' % (bn, sn) + bufSizes += 1 + yield AFTER, 'ctu->cpu.writemem(%s, %s, %s);' % (an, bn, sn) + yield AFTER, 'delete[] %s;' % bn + elif type == 'object': + yield AFTER, '%s = new %s(resp.move_handles[%i]);' % (name, rest[0][0], objOff) + objOff += 1 + elif type == 'KObject': + hndOff += 1 + elif type == 'pid': + assert False + else: + if elem[0] == 'align': + alignment = elem[1] + elem = elem[2] + else: + alignment = min(8, typeSize(elem)) + while outOffset % alignment: + outOffset += 1 + if isPointerType(elem): + tn = tempname() + yield 'auto %s = resp.getDataPointer<%s>(%s);' % (tn, retype(elem, noIndex=True), emitInt(outOffset)) + params.append(tn) + else: + params.append('*resp.getDataPointer<%s *>(%s)' % (retype(elem), emitInt(outOffset))) + outOffset += typeSize(elem) + + yield 'auto ret = ipc_send(session, &req, &resp);' + yield AFTER + yield 'return ret;' + +def reorder(gen): + after = [] + for x in gen: + if x == AFTER: + for elem in after: + yield elem + elif isinstance(x, tuple) and x[0] == AFTER: + after.append(x[1]) + else: + yield x + +def parsePartials(code): + code = '\n'.join(re.findall(r'/\*\$IPC\$(.*?)\*/', code, re.M|re.S)) + return partialparser.parse(code) + +def main(): + global allTypes + + types, ifaces, services = idparser.getAll() + + allTypes = types + + typesByNs = splitByNs(types) + ifacesByNs = splitByNs(ifaces) + + namespaces = {x : [] for x in typesByNs.keys() + ifacesByNs.keys()} + + for ns, types in typesByNs.items(): + for name, spec in sorted(types.items(), key=lambda x: x[0]): + retyped, plain = retype(spec, noIndex=True), retype(spec) + namespaces[ns].append('using %s = %s;%s' % (name, retyped, ' // ' + plain if retyped != plain else '')) + + for ns, ifaces in ifacesByNs.items(): + for name in sorted(ifaces.keys()): + namespaces[ns].append('class %s;' % name) + + with file('lib/ipcClients.h', 'w') as fp: + print >>fp, '#pragma once' + print >>fp, '#include' + print >>fp + + for ns, elems in sorted(namespaces.items(), key=lambda x: x[0]): + if ns is not None: + print >>fp, 'namespace %s {' % ns + hasUsing = False + for elem in elems: + if not hasUsing and elem.startswith('using'): + hasUsing = True + elif hasUsing and elem.startswith('class'): + print >>fp + hasUsing = False + print >>fp, ('\t' if ns is not None else '') + elem + if ns is not None: + print >>fp, '}' + + print >>fp + + for ns, ifaces in sorted(ifacesByNs.items(), key=lambda x: x[0]): + print >>fp, '%snamespace %s {' % ('//// ' if ns is None else '', ns) + for name, funcs in sorted(ifaces.items(), key=lambda x: x[0]): + qname = '%s::%s' % (ns, name) if ns else name + print >>fp, '\tclass %s {' % name + print >>fp, '\tpublic:' + print >>fp, '\t\t%s();' % name + for fname, func in sorted(funcs.items(), key=lambda x: x[0]): + print >>fp, '\t\tuint32_t %s(%s);' % (fname, generatePrototype(func)) + print >>fp, '\t};' + print >>fp, '%s}' % ('//// ' if ns is None else '') + + print >>fp, '#ifdef DEFINE_CALLERS' + for name, funcs in sorted(ifaces.items(), key=lambda x: x[0]): + qname = '%s::%s' % (ns, name) if ns else name + for fname, func in sorted(funcs.items(), key=lambda x: x[0]): + print >>fp, 'uint32_t %s::%s(%s) {' % (qname, fname, generatePrototype(func)) + print >>fp, '\tipc_request_t req;' + print >>fp, '\tipc_response_t resp;' + print >>fp, '\tmemset(&req, 0, sizeof(ipc_request_t));' + print >>fp, '\n'.join('\t' + x for x in reorder(generateCaller(qname, fname, func))) + print >>fp, '}' + print >>fp, '#endif // DEFINE_CALLERS' + +if __name__=='__main__': + main(*sys.argv[1:])