BreadFish64

#include "matrix.hpp"

#include <immintrin.h>

#include <cstring>
#include <future>
#include <vector>

// Anonymous namespace for internal linkage
namespace {

BreadFish64

//!DESC FSR_EASU
//!HOOK MAINPRESUB
//!BIND HOOKED
//!WIDTH OUTPUT.w
//!HEIGHT OUTPUT.h
//!COMPUTE 8 8

#extension GL_GOOGLE_include_directive : enable

#define SAMPLE_EASU 1

BreadFish64

#include <algorithm>
#include <array>
#include <bit>
#include <chrono>
#include <cstdint>
#include <cstdlib>
#include <cstring>
#include <memory>
#include <random>
#include <string>

BreadFish64

//!DESC ScaleForce
//!HOOK MAINPRESUB
//!BIND HOOKED
//!WIDTH OUTPUT.w
//!HEIGHT OUTPUT.h
//? #version 450 core

#ifndef HOOKED_tex
// Copy MPV built-ins for IDE
#define tex1D texture

BreadFish64

#version 330

in vec2 TexCoord;

out vec4 FragColor;

uniform sampler2D Texture;

vec3 dtt = vec3(65536.0,255.0,1.0);

BreadFish64

class Solution {
public:
    [[gnu::target("avx2")]] int reverse(int x) const {
        bool negative = x < 0;
        if (negative) {
            if (x == std::numeric_limits<int>::min())
                return 0;
            x = -x;
        }
        if (x >= 10) {

BreadFish64

#include <algorithm>
#include <string>

class Solution {
public:
    std::string longestPalindrome(const std::string& s) const {
        std::size_t longest{0};
        std::string::const_iterator longest_begin, longest_end;
        // The search will start at the center of a potential palindrome
        // and work outward to find the length.

BreadFish64

#pragma once

#include <functional>
#include "opcode.hpp"

namespace GBA::CPU::DataProcessing {

namespace Basic {
using DataProcessingOperation = void (*)(ProcessorState& state, u32 operand_one, u32 operand_two,
                                         bool carry_in, u32& result) noexcept;

BreadFish64

#pragma once

#include <limits>

#include "types.hpp"

namespace GBA {

template <typename Storage, usize start, usize end, typename IO = Storage>
class BitField {

BreadFish64

#version 450

in vec2 tex_coord;

out vec4 frag_color;

layout(binding = 0) uniform sampler2D input_texure;

vec4 cubic(float v) {
    vec4 n = vec4(1.0, 2.0, 3.0, 4.0) - v;