### Complete Libtransistor Application Example

Source: https://context7.com/reswitched/libtransistor/llms.txt

A minimal application demonstrating initialization, main loop, and cleanup patterns using libtransistor services like SM and HID. Includes error handling.

```c
#include <libtransistor/nx.h>
#include <stdio.h>

#define ASSERT_OK(label, expr) if ((r = (expr)) != RESULT_OK) { 
    printf("Error at %s:%d: 0x%x\n", __FILE__, __LINE__, r);
    goto label;
}

int main() {
    result_t r;

    // Allow system time to stabilize
    svcSleepThread(100000000);

    // Initialize services in dependency order
    ASSERT_OK(fail, sm_init());
    ASSERT_OK(fail_sm, hid_init());

    printf("Application started!\n");

    hid_shared_memory_t *hid = hid_get_shared_memory();
    hid_controller_t *controller = &hid->controllers[8];

    // Main application loop
    bool running = true;
    while (running) {
        // Read controller input
        hid_controller_state_entry_t state =
            controller->main.entries[controller->main.latest_idx];

        // Check for exit condition (+ button)
        if (state.button_state & BUTTON_PLUS) {
            printf("Exit requested\n");
            running = false;
        }

        // Process other input
        if (state.button_state & BUTTON_A) {
            printf("A pressed\n");
        }

        // Frame delay
        svcSleepThread(16666667); // ~60 FPS
    }

    printf("Shutting down...\n");

    // Cleanup in reverse order
    hid_finalize();
fail_sm:
    sm_finalize();
fail:
    return (r != RESULT_OK) ? 1 : 0;
}

```

--------------------------------

### Libtransistor Project Makefile Setup

Source: https://context7.com/reswitched/libtransistor/llms.txt

Sets up a Makefile to build libtransistor applications, including NRO and NSO formats. Ensure LIBTRANSISTOR_HOME is set.

```makefile
# Makefile for libtransistor application

TARGET := myapp
OBJECTS := main.o utils.o

# NRO metadata (optional, for homebrew menu)
NRO_ICON     := icon.jpg
NRO_NAME     := My Application
NRO_DEVELOPER := Developer Name
NRO_VERSION  := 1.0.0

# Build both NRO and NSO formats
all: $(TARGET).nro $(TARGET).nso

clean:
	rm -f *.o *.nro *.nso *.so

# Include libtransistor build rules
ifndef LIBTRANSISTOR_HOME
    $(error LIBTRANSISTOR_HOME must be set)
endif
include $(LIBTRANSISTOR_HOME)/libtransistor.mk

# Link NRO binary
$(TARGET).nro.so: $(OBJECTS) $(LIBTRANSITOR_NRO_LIB) $(LIBTRANSISTOR_COMMON_LIBS)
	$(LD) $(LD_FLAGS) -o $@ $(OBJECTS) $(LIBTRANSISTOR_NRO_LDFLAGS)

# Link NSO binary
$(TARGET).nso.so: $(OBJECTS) $(LIBTRANSITOR_NSO_LIB) $(LIBTRANSISTOR_COMMON_LIBS)
	$(LD) $(LD_FLAGS) -o $@ $(OBJECTS) $(LIBTRANSISTOR_NSO_LDFLAGS)

```

--------------------------------

### Start GDB Server with CTU

Source: https://github.com/reswitched/libtransistor/blob/development/README.md

Use the CTU tool to load your libtransistor NRO binary and enable the GDB server. This command starts a GDB server on port 24689 and waits for a GDB client to connect.

```bash
$ ./ctu --load-nro <path-to-libtransistor>/build/test/<binary>.nro --enable-gdb
[GdbStub] INFO: Starting GDB server on port 24689...
[GdbStub] INFO: Waiting for gdb to connect...
```

--------------------------------

### BSD Sockets TCP Client and Server Example

Source: https://context7.com/reswitched/libtransistor/llms.txt

Demonstrates creating a TCP client to connect to a server, send data, and receive a response. Also shows setting up a basic TCP server to accept connections and send a welcome message. Ensure BSD services are finalized.

```c
#include <libtransistor/nx.h>
#include <sys/socket.h>
#include <netinet/in.h>

result_t r;

// Initialize services
r = sm_init();
if (r != RESULT_OK) return 1;

r = bsd_init();
if (r != RESULT_OK) {
    printf("BSD init failed: 0x%x, errno: %d\n", r, bsd_errno);
    sm_finalize();
    return 1;
}

// TCP Client example
int client_fd = bsd_socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (client_fd < 0) {
    printf("Socket creation failed: errno %d\n", bsd_errno);
    goto cleanup;
}

struct sockaddr_in server_addr = {
    .sin_family = AF_INET,
    .sin_port = htons(8080),
    .sin_addr.s_addr = htonl(0x7F000001) // 127.0.0.1
};

if (bsd_connect(client_fd, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
    printf("Connect failed: errno %d\n", bsd_errno);
    bsd_close(client_fd);
    goto cleanup;
}

// Send data
const char *message = "Hello from Nintendo Switch!";
if (bsd_send(client_fd, message, strlen(message), 0) < 0) {
    printf("Send failed: errno %d\n", bsd_errno);
}

// Receive response
char buffer[512];
int bytes = bsd_recv(client_fd, buffer, sizeof(buffer) - 1, 0);
if (bytes > 0) {
    buffer[bytes] = '\0';
    printf("Received: %s\n", buffer);
}

bsd_close(client_fd);

// TCP Server example
int server_fd = bsd_socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
struct sockaddr_in bind_addr = {
    .sin_family = AF_INET,
    .sin_port = htons(4444),
    .sin_addr.s_addr = INADDR_ANY
};

bsd_bind(server_fd, (struct sockaddr*)&bind_addr, sizeof(bind_addr));
bsd_listen(server_fd, 5);

struct sockaddr_in client_addr;
socklen_t addr_len = sizeof(client_addr);
int conn_fd = bsd_accept(server_fd, (struct sockaddr*)&client_addr, &addr_len);
if (conn_fd >= 0) {
    bsd_send(conn_fd, "Welcome!", 8, 0);
    bsd_close(conn_fd);
}
bsd_close(server_fd);

cleanup:
bsd_finalize();
sm_finalize();

```

--------------------------------

### Build libtransistor on OSX

Source: https://github.com/reswitched/libtransistor/blob/development/README.md

Installs the 'squashfs' dependency using Homebrew for building libtransistor on macOS.

```bash
brew install squashfs
```

--------------------------------

### Build libtransistor on Fedora

Source: https://github.com/reswitched/libtransistor/blob/development/README.md

Instructions for building libtransistor on Fedora, including setting up the PATH for clang and lld, and installing necessary development packages.

```bash
wget -c http://releases.llvm.org/5.0.1/clang+llvm-5.0.1-x86_64-linux-gnu-Fedora27.tar.xz
tar xpf clang+llvm-5.0.1-x86_64-linux-gnu-Fedora27.tar.xz
export PATH=`pwd`/clang+llvm-5.0.1-x86_64-linux-gnu-Fedora27/bin:$PATH
cd libtransistor
make
```

```bash
sudo dnf -y install libstdc++-devel gcc-c++.x86_64
```

--------------------------------

### Initialize and Mount SD Card Filesystem

Source: https://context7.com/reswitched/libtransistor/llms.txt

Initializes the filesystem service, mounts the SD card, and creates a virtual filesystem inode. This setup is required before performing any file operations on the SD card.

```c
#include <libtransistor/nx.h>
#include <libtransistor/fs/fs.h>
#include <libtransistor/fs/fspfs.h>
#include <libtransistor/ipc/fs.h>
#include <stdio.h>
#include <fcntl.h>

result_t r;

r = sm_init();
if (r != RESULT_OK) return 1;

// Initialize filesystem service
r = fsp_srv_init(0);
if (r != RESULT_OK) { sm_finalize(); return 1; }

// Mount SD card
ifilesystem_t sdcard_fs;
r = fsp_srv_mount_sd_card(&sdcard_fs);
if (r != RESULT_OK) {
    printf("Failed to mount SD card: 0x%x\n", r);
    goto cleanup;
}

// Create filesystem inode and mount at /sd
trn_inode_t sdcard_inode;
trn_fspfs_create(&sdcard_inode, sdcard_fs);
r = trn_fs_mount("/sd", sdcard_inode);
if (r != RESULT_OK) {
    printf("Failed to mount at /sd: 0x%x\n", r);
    goto cleanup;
}

// Now use standard POSIX file operations
FILE *f = fopen("/sd/myfile.txt", "w");
if (f) {
    fprintf(f, "Hello from libtransistor!\n");
    fclose(f);
}

// Read back the file
f = fopen("/sd/myfile.txt", "r");
if (f) {
    char buffer[256];
    while (fgets(buffer, sizeof(buffer), f)) {
        printf("Read: %s", buffer);
    }
    fclose(f);
}

// Create directories
trn_fs_mkdir("/sd/myapp");
trn_fs_mkdir("/sd/myapp/data");

// List directory contents
trn_dir_t dir;
r = trn_fs_opendir(&dir, "/sd");
if (r == RESULT_OK) {
    // Iterate directory entries...
}

cleanup:
fsp_srv_finalize();
sm_finalize();

```

--------------------------------

### Build libtransistor on Arch Linux

Source: https://github.com/reswitched/libtransistor/blob/development/README.md

Installs necessary system packages and Python dependencies for building libtransistor on Arch Linux.

```bash
sudo pacman -S llvm clang lld python python-pip squashfs-tools base-devel git cmake
```

```bash
pip install --user -r requirements.txt
```

--------------------------------

### Waiter Event Loop Setup and Execution

Source: https://context7.com/reswitched/libtransistor/llms.txt

Sets up an event loop using the waiter subsystem to handle asynchronous events like V-Sync, timers, and cross-thread signals. It demonstrates adding, waiting on, and canceling event records.

```c
#include <libtransistor/waiter.h>
#include <libtransistor/svc.h>

bool on_vsync(void *data, handle_t handle) {
    printf("V-Sync event received\n");
    svcResetSignal(handle);
    return true; // Keep registered
}

uint64_t on_timer(void *data) {
    static int count = 0;
    printf("Timer fired: %d\n", ++count);

    if (count >= 10) {
        return 0; // Unregister timer
    }

    // Return next deadline (100ms from now in system ticks)
    return svcGetSystemTick() + (19200000 / 10);
}

bool on_signal(void *data) {
    waiter_t *waiter = (waiter_t*)data;
    printf("Received cross-thread signal\n");
    // waiter_reset_signal(waiter, record); // Call from within callback
    return true;
}

int main() {
    waiter_t *waiter = waiter_create();
    if (!waiter) return 1;

    // Add handle to wait on (e.g., V-Sync event)
    revent_h vsync_event;
    // ... obtain vsync_event from display system ...
    wait_record_t *vsync_record = waiter_add(waiter, vsync_event, on_vsync, NULL);

    // Add timer callback (fires in 100ms)
    uint64_t deadline = svcGetSystemTick() + (19200000 / 10);
    wait_record_t *timer_record = waiter_add_deadline(waiter, deadline, on_timer, NULL);

    // Add cross-thread signal
    wait_record_t *signal_record = waiter_add_signal(waiter, on_signal, waiter);

    // Main event loop
    for (int i = 0; i < 100; i++) {
        result_t r = waiter_wait(waiter, 1000000000); // 1 second timeout
        if (r != RESULT_OK && r != 0xea01) { // 0xea01 = timeout
            printf("Waiter error: 0x%x\n", r);
            break;
        }
    }

    // Cleanup
    waiter_cancel(waiter, vsync_record);
    waiter_cancel(waiter, timer_record);
    waiter_cancel(waiter, signal_record);
    waiter_destroy(waiter);

    return 0;
}

```

--------------------------------

### Connect GDB to Remote Target

Source: https://github.com/reswitched/libtransistor/blob/development/README.md

Connect to the GDB server started by CTU. You will need to add the symbol file for your binary to allow GDB to properly interpret the memory addresses and symbols.

```bash
$ aarch64-none-elf-gdb 
(gdb) target remote localhost:24689
Remote debugging using localhost:24689
warning: No executable has been specified and target does not support
determining executable automatically.  Try using the "file" command.
0x0000007100000080 in ?? ()
```

```bash
(gdb) add-symbol-file <path-to-libtransistor>/build/test/<binary>.nro.so 0x7100000000 -s .bss 0x7100000000
add symbol table from file "<path-to-libtransistor>/build/test/<binary>.nro.so" at
	.text_addr = 0x7100000000
	.bss_addr = 0x7100000000
(y or n) y
Reading symbols from <path-to-libtransistor>/build/test/<binary>.nro.so...done.
(gdb) 
```

--------------------------------

### Initialize Display Subsystem and Render Frames

Source: https://context7.com/reswitched/libtransistor/llms.txt

Initializes the display, GPU, and VI services. Opens a display layer, synchronizes with V-Sync, and renders frames with solid colors. Ensure all services are finalized on exit.

```c
#include <libtransistor/nx.h>

result_t r;

// Initialize all required services
r = sm_init();
if (r != RESULT_OK) return 1;

r = gpu_initialize();
if (r != RESULT_OK) { sm_finalize(); return 1; }

r = vi_init();
if (r != RESULT_OK) { gpu_finalize(); sm_finalize(); return 1; }

r = display_init();
if (r != RESULT_OK) { vi_finalize(); gpu_finalize(); sm_finalize(); return 1; }

// Open a display layer (creates rendering surface)
surface_t surface;
r = display_open_layer(&surface);
if (r != RESULT_OK) goto cleanup;

// Get buffer event for V-Sync synchronization
revent_h vsync_event;
r = surface_get_buffer_event(&surface, &vsync_event);
if (r != RESULT_OK) goto cleanup_layer;

// Rendering loop
for (int frame = 0; frame < 300; frame++) {
    // Wait for V-Sync
    uint32_t handle_idx;
    r = svcWaitSynchronization(&handle_idx, &vsync_event, 1, 33333333);
    if (r == RESULT_OK) {
        svcResetSignal(vsync_event);
    }

    // Dequeue a buffer for rendering
    uint32_t *framebuffer;
    r = surface_dequeue_buffer(&surface, &framebuffer);
    if (r != RESULT_OK) break;

    // Wait for GPU to finish with buffer
    surface_wait_buffer(&surface);

    // Fill with solid color (ARGB format)
    uint32_t color = (frame < 150) ? 0xFFFF0000 : 0xFF0000FF; // Red then Blue
    for (size_t i = 0; i < (0x3c0000 / sizeof(uint32_t)); i++) {
        framebuffer[i] = color;
    }

    // Blit an image with GPU-compatible swizzling
    // gfx_slow_swizzling_blit(framebuffer, image_pixels, width, height, x, y);

    // Submit buffer for display
    r = surface_queue_buffer(&surface);
    if (r != RESULT_OK) break;
}

// Cleanup
svcCloseHandle(vsync_event);
cleanup_layer:
display_close_layer(&surface);
cleanup:
display_finalize();
vi_finalize();
gpu_finalize();
sm_finalize();

```

--------------------------------

### Initialize and Play PCM Audio

Source: https://context7.com/reswitched/libtransistor/llms.txt

Initializes the audio subsystem, lists available outputs, opens the first one, and plays a sine wave using double-buffered PCM audio. Ensure audio_ipc_init() is called before this. Handles cleanup on error.

```c
#include <libtransistor/nx.h>

#define SAMPLE_RATE 48000
#define NUM_CHANNELS 2
#define FRAMES_PER_BUFFER 4800

typedef struct { int16_t left; int16_t right; } stereo_frame_t;

result_t r;

r = sm_init();
if (r != RESULT_OK) return 1;

r = audio_ipc_init();
if (r != RESULT_OK) { sm_finalize(); return 1; }

// List available audio outputs
char output_names[8][0x20];
uint32_t num_outputs;
r = audio_ipc_list_outputs(&output_names[0], 8, &num_outputs);
if (r != RESULT_OK || num_outputs == 0) goto cleanup;

// Open the first audio output
audio_output_t audio_out;
r = audio_ipc_open_output(output_names[0], &audio_out);
if (r != RESULT_OK) goto cleanup;

printf("Audio: %d Hz, %d channels\n", audio_out.sample_rate, audio_out.num_channels);

// Register for buffer release notifications
handle_t buffer_event;
r = audio_ipc_output_register_buffer_event(&audio_out, &buffer_event);
if (r != RESULT_OK) goto close_output;

// Prepare double buffers
size_t buffer_size = FRAMES_PER_BUFFER * sizeof(stereo_frame_t);
audio_output_buffer_t buffers[2];

for (int i = 0; i < 2; i++) {
    buffers[i].ptr = &buffers[i].sample_data;
    buffers[i].sample_data = alloc_pages(buffer_size, buffer_size, NULL);
    buffers[i].buffer_size = buffer_size;
    buffers[i].data_size = buffer_size;
    buffers[i].unknown = 0;

    // Fill with audio data (sine wave example)
    stereo_frame_t *frames = (stereo_frame_t*)buffers[i].sample_data;
    for (int f = 0; f < FRAMES_PER_BUFFER; f++) {
        int16_t sample = (int16_t)(sin(f * 440.0 * 2.0 * M_PI / SAMPLE_RATE) * 0x7FFF * 0.5);
        frames[f].left = sample;
        frames[f].right = sample;
    }

    audio_ipc_output_append_buffer(&audio_out, &buffers[i]);
}

// Start playback
audio_ipc_output_start(&audio_out);

// Audio loop - refill released buffers
for (int i = 0; i < 500; i++) {
    uint32_t handle_idx;
    if (svcWaitSynchronization(&handle_idx, &buffer_event, 1, 100000000) == RESULT_OK) {
        svcResetSignal(buffer_event);

        audio_output_buffer_t *released;
        uint32_t num_released;
        while (audio_ipc_output_get_released_buffer(&audio_out, &num_released, &released) == RESULT_OK
               && released != NULL) {
            // Refill buffer with new audio data...
            audio_ipc_output_append_buffer(&audio_out, released);
        }
    }
}

audio_ipc_output_stop(&audio_out);

close_output:
audio_ipc_output_close(&audio_out);
cleanup:
audio_ipc_finalize();
sm_finalize();

```

--------------------------------

### Service Manager Initialization and Usage

Source: https://context7.com/reswitched/libtransistor/llms.txt

Initializes the Service Manager (sm) for accessing system services. Remember to finalize when done. Handles service registration and retrieval.

```c
#include <libtransistor/ipc/sm.h>

// Initialize the Service Manager
result_t r = sm_init();
if (r != RESULT_OK) {
    printf("Failed to initialize SM: 0x%x\n", r);
    return 1;
}

// Get a specific service by name
ipc_object_t service;
r = sm_get_service(&service, "hid");
if (r == RESULT_OK) {
    // Use the service...
    ipc_close(service);
}

// Register a custom service
port_h port;
r = sm_register_service(&port, "myservice", 4); // max 4 sessions
if (r == RESULT_OK) {
    // Handle incoming connections on port...
    sm_unregister_service("myservice");
}

// Always finalize when done
sm_finalize();
```

--------------------------------

### C Function Definition with Braces and sizeof

Source: https://github.com/reswitched/libtransistor/blob/development/STYLE.md

Illustrates the style for function definitions, including brace placement and spacing around function calls and keywords like 'sizeof'.

```c
void foo(int bar, int baz) {
	return sizeof(bar);
}
```

--------------------------------

### Initialize and Use IPC Service

Source: https://context7.com/reswitched/libtransistor/llms.txt

Initializes the System Manager (SM) service and obtains a handle to a system service like 'time:s'. This is the first step for inter-process communication with system services.

```c
#include <libtransistor/ipc.h>
#include <libtransistor/ipc/sm.h>

result_t r;

r = sm_init();
if (r != RESULT_OK) return 1;

// Get a service object
ipc_object_t service;
r = sm_get_service(&service, "time:s");
if (r != RESULT_OK) {
    printf("Failed to get time service: 0x%x\n", r);
    sm_finalize();
    return 1;
}

// Prepare an IPC request
ipc_request_t request = ipc_default_request;
request.request_id = 0; // GetStandardUserSystemClock

// Prepare response format
ipc_object_t clock_object;
ipc_response_fmt_t response = ipc_default_response_fmt;
response.num_objects = 1;
response.objects = &clock_object;

// Send the request
r = ipc_send(service, &request, &response);
if (r == RESULT_OK) {
    printf("Got clock object, id: %d\n", clock_object.object_id);

    // Use the clock object for further requests...

    ipc_close(clock_object);
}

// Convert to domain for efficient multi-object handling
ipc_domain_t domain;
r = ipc_convert_to_domain(&service, &domain);
if (r == RESULT_OK) {
    // All objects now share the same session
    ipc_close_domain(domain);
} else {
    ipc_close(service);
}

sm_finalize();

```

--------------------------------

### Create and Manage Threads with Mutex

Source: https://context7.com/reswitched/libtransistor/llms.txt

Demonstrates creating multiple threads that safely increment a shared counter using a mutex. Threads are created with specified priority, processor affinity, and stack size, then joined for completion.

```c
#include <libtransistor/thread.h>
#include <libtransistor/mutex.h>
#include <libtransistor/svc.h>

// Thread-safe counter
static trn_mutex_t counter_mutex = TRN_MUTEX_STATIC_INITIALIZER;
static int shared_counter = 0;

void worker_thread(void *arg) {
    int thread_id = (int)(intptr_t)arg;

    for (int i = 0; i < 100; i++) {
        trn_mutex_lock(&counter_mutex);
        shared_counter++;
        printf("Thread %d: counter = %d\n", thread_id, shared_counter);
        trn_mutex_unlock(&counter_mutex);

        svcSleepThread(1000000); // 1ms
    }

    printf("Thread %d finished\n", thread_id);
}

int main() {
    result_t r;
    trn_thread_t threads[4];

    // Create multiple threads
    for (int i = 0; i < 4; i++) {
        r = trn_thread_create(
            &threads[i],
            worker_thread,      // Entry function
            (void*)(intptr_t)i, // Argument
            0x3F,               // Priority (0x00-0x3F, higher = lower priority)
            -2,                 // Processor ID (-2 = don't care)
            64 * 1024,          // Stack size (64KB)
            NULL                // Stack (NULL = auto-allocate)
        );

        if (r != RESULT_OK) {
            printf("Failed to create thread %d: 0x%x\n", i, r);
            continue;
        }

        r = trn_thread_start(&threads[i]);
        if (r != RESULT_OK) {
            printf("Failed to start thread %d: 0x%x\n", i, r);
            trn_thread_destroy(&threads[i]);
        }
    }

    // Wait for all threads to complete
    for (int i = 0; i < 4; i++) {
        r = trn_thread_join(&threads[i], -1); // -1 = no timeout
        if (r == RESULT_OK) {
            printf("Thread %d joined\n", i);
        }
        trn_thread_destroy(&threads[i]);
    }

    printf("Final counter value: %d\n", shared_counter);
    return 0;
}

```

--------------------------------

### C Goto Statement for Error Handling

Source: https://github.com/reswitched/libtransistor/blob/development/STYLE.md

Demonstrates the use of goto statements for error handling, a pattern encouraged for reducing code duplication and improving readability, especially with multiple resource acquisitions.

```c
void func() {
	result_t r = RESULT_OK; // this is one of those cases where the meaning of the variable is clear both from usage and because it's a recurring pattern
	if((r =  sm_init()) != RESULT_OK) { goto fail; }
	if((r = bsd_init()) != RESULT_OK) { goto fail_sm; }
	
	// code goes here
	
bsd_finalize();
fail_sm:
	sm_finalize();
fail:
	return r;
}
```

--------------------------------

### Run libtransistor NRO binary

Source: https://github.com/reswitched/libtransistor/blob/development/README.md

Command to run a compiled NRO binary using the 'ctu' tool, with an option to enable sockets for the 'bsd' test.

```bash
./ctu --load-nro <path-to-libtransistor>/build/test/<binary>.nro
```

```bash
$ ./ctu --load-nro <path-to-libtransistor>/build/test/<binary>.nro --enable-sockets
```

--------------------------------

### Clone libtransistor Repository

Source: https://github.com/reswitched/libtransistor/blob/development/README.md

Use this command to clone the libtransistor repository, ensuring all submodules are also fetched.

```bash
git clone --recursive https://github.com/reswitched/libtransistor
```

--------------------------------

### C switch-case Statement with Fall-through

Source: https://github.com/reswitched/libtransistor/blob/development/STYLE.md

Demonstrates the preferred indentation for switch-case statements, including acceptable fall-through with comments. Ensure 'case' aligns with 'switch'.

```c
switch(value) {
case 0x7777:
case 0x8888:
case 0x9999:
	break;
case 0xAAAA:
	do_something();
	// fall-througth
case 0xBBBB:
	do_another_thing();
	break;
}
```

--------------------------------

### HID Input Handling

Source: https://context7.com/reswitched/libtransistor/llms.txt

Initializes HID for controller and touchscreen input. Accesses shared memory for state polling. Handles button presses and analog stick movements.

```c
#include <libtransistor/nx.h>

result_t r;

// Initialize services
r = sm_init();
if (r != RESULT_OK) return 1;

r = hid_init();
if (r != RESULT_OK) {
    sm_finalize();
    return 1;
}

// Get shared memory for direct access to controller state
hid_shared_memory_t *shm = hid_get_shared_memory();
hid_controller_t *controllers = shm->controllers;

// Main input loop
for (int frame = 0; frame < 1000; frame++) {
    // Read controller #8 (handheld mode or first paired controller)
    hid_controller_t *controller = &controllers[8];
    hid_controller_state_t *state = &controller->main;
    hid_controller_state_entry_t entry = state->entries[state->latest_idx];

    // Check button states using bitmasks
    if (entry.button_state & BUTTON_A) {
        printf("A button pressed!\n");
    }
    if (entry.button_state & BUTTON_B) {
        printf("B button pressed!\n");
    }

    // Read analog stick positions (-32768 to 32767)
    int32_t left_x = entry.left_stick_x;
    int32_t left_y = entry.left_stick_y;
    printf("Left stick: (%d, %d)\n", left_x, left_y);

    // Read touchscreen input
    hid_touchscreen_t *touchscreen = &shm->touchscreen;
    hid_touch_entry_t touch = touchscreen->touch_entry[touchscreen->latest_idx];

    for (uint64_t i = 0; i < touch.num_touches; i++) {
        printf("Touch %lu at (%u, %u)\n", i,
               touch.touch_data[i].touch_x,  // 0-1280
               touch.touch_data[i].touch_y); // 0-720
    }

    svcSleepThread(16666667); // ~60 FPS
}

// Cleanup
hid_finalize();
sm_finalize();
```

--------------------------------

### C if-else if-else Statement Structure

Source: https://github.com/reswitched/libtransistor/blob/development/STYLE.md

Demonstrates the required brace usage and placement of 'else' and 'else if' keywords on the same line as surrounding braces.

```c
if(a) {
	single_statement();
} else if(b) {
	another_single_statement();
} else {
	two();
	statements();
}
```

--------------------------------

### Libtransistor Supervisor Calls (SVC)

Source: https://context7.com/reswitched/libtransistor/llms.txt

Provides direct access to kernel functionality for memory management, thread control, synchronization, and debugging. Ensure necessary headers are included.

```c
#include <libtransistor/svc.h>

// Memory management
void *heap_addr;
result_t r = svcSetHeapSize(&heap_addr, 0x200000); // 2MB heap
if (r == RESULT_OK) {
    printf("Heap allocated at %p\n", heap_addr);
}

// Query memory region info
memory_info_t mem_info;
uint32_t page_info;
svcQueryMemory(&mem_info, &page_info, heap_addr);
printf("Memory at %p: size=0x%lx, type=%d, perm=%d\n",
       mem_info.base_addr, mem_info.size, mem_info.memory_type, mem_info.permission);

// Thread sleep
svcSleepThread(1000000000); // Sleep for 1 second (in nanoseconds)

// Get system tick for timing
uint64_t start = svcGetSystemTick();
// ... do work ...
uint64_t elapsed = svcGetSystemTick() - start;
printf("Elapsed: %lu ticks (%f ms)\n", elapsed, elapsed / 19200.0);

// Synchronization - wait on multiple handles
handle_t handles[3] = { event1, event2, event3 };
uint32_t signaled_idx;
r = svcWaitSynchronization(&signaled_idx, handles, 3, 5000000000); // 5 second timeout
if (r == RESULT_OK) {
    printf("Handle %d was signaled\n", signaled_idx);
    svcResetSignal(handles[signaled_idx]);
} else if (r == 0xea01) {
    printf("Timeout waiting for events\n");
}

// Create and signal events
wevent_h write_event;
revent_h read_event;
svcCreateEvent(&write_event, &read_event);
svcSignalEvent(write_event);  // Signal the event
svcClearEvent(read_event);    // Clear the event
svcCloseHandle(write_event);
svcCloseHandle(read_event);

// Debug output
char msg[] = "Debug message";
svcOutputDebugString(msg, sizeof(msg));

// Get process/thread info
uint64_t pid;
svcGetProcessId(&pid, CURRENT_PROCESS);
printf("Current process ID: %lu\n", pid);

```

--------------------------------

### C Inline if Statements with Braces

Source: https://github.com/reswitched/libtransistor/blob/development/STYLE.md

Shows the style for concise if statements on a single line when readability is maintained. Braces are mandatory.

```c
if(condition)        { do_something(); }
if(longer condition) { do_thing(); }
if(third condition)  { return; }
```

--------------------------------

### C Ternary Operator with Parentheses for Readability

Source: https://github.com/reswitched/libtransistor/blob/development/STYLE.md

Illustrates the use of parentheses to enhance readability when multiple operators are present in ternary expressions. Whitespace around binary/ternary operators is encouraged.

```c
return a ? (b ? (c + d) * e-- : -f.g) : h->i;
```

--------------------------------

### Core Types and Constants

Source: https://context7.com/reswitched/libtransistor/llms.txt

Defines fundamental types like handles and result codes, along with utility macros. Ensure operations return RESULT_OK.

```c
#include <libtransistor/types.h>

// Core type definitions
typedef uint32_t handle_t;            // Resource handle
typedef handle_t thread_h;            // Thread handle
typedef handle_t session_h;           // Session handle
typedef handle_t revent_h;            // Read event handle
typedef uint32_t result_t;            // Function result

// Success constant
#define RESULT_OK 0

// Bit manipulation macro
#define BIT(n) (1U<<(n))

// Example usage - checking operation result
result_t r = some_operation();
if (r != RESULT_OK) {
    printf("Operation failed with error: 0x%x\n", r);
}
```

--------------------------------

### C Pointer Dereferencing and Casting Style

Source: https://github.com/reswitched/libtransistor/blob/development/STYLE.md

Illustrates the style for pointer dereferencing and casting, where the '*' symbol is adjacent to the identifier or type.

```c
uint32_t example(uint64_t *a) {
	return *((uint32_t*) a);
}
```

--------------------------------

### C Compound Assignment Operator Style

Source: https://github.com/reswitched/libtransistor/blob/development/STYLE.md

Shows the style for compound assignment operators, where the operator is adjacent to the variable being assigned.

```c
a+= b;
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.