lipsum shimamura-sakura

## kaku.js
'use strict';

module.exports = {
    workNextData,
    parseWorkHTML,
    parseEpisodeHTML,
};

let lazy_JSDOM = null;

## box.zig
const std = @import("std");
const Allocator = std.mem.Allocator;

pub fn box(allocator: Allocator, value: anytype) !*@TypeOf(value) {
    const ptr = try allocator.create(@TypeOf(value));
    ptr.* = value;
    return ptr;
}

test {

## struct-tuple-init.zig
const std = @import("std");

pub fn StructFieldsTuple(comptime T: type) type {
    var info = switch (@typeInfo(T)) {
        .Struct => |st| st,
        else => @compileError("T must be a struct"),
    };
    var newFields = info.fields[0..info.fields.len].*;
    inline for (&newFields, 0..) |*f, i| f.name = std.fmt.comptimePrint("{}", .{i});
    info.decls = &.{};

## slice.zig
fn Slice(comptime T: anytype) type {
    return struct {
        const Self = @This();
        const Error = error{EOF};
        left: T,
        pub fn take(self: *Self, n: anytype) Error!@TypeOf(self.left[0..n]) {
            if (self.left.len < n) return Error.EOF;
            defer self.left = self.left[n..];
            return self.left[0..n];
        }

## goo-blog-copy.js
document.body.onclick = () => {
    document.body.onclick = null;
    navigator.clipboard.writeText(location.href + '\n\n' +
        document.querySelector('article .mod-entry-set').innerText);
    al = document.querySelectorAll('div.entry-bottom-pn>a');
    if (al.length < 3) return alert('no next link');
    window.location = al[2].href;
};

// bookmark this:

## libdeflate.zig
const c = @cImport(@cInclude("libdeflate.h"));

pub const Error = error{
    LibDeflateAlloc,
    LibDeflateBadData,
    LibDeflateShortOutput,
    LibDeflateInsufficientSpace,
    LibDeflateOther,
};

## dsp-adpcm.zig
const std = @import("std");
const hea = std.heap.page_allocator;

pub fn main() anyerror!void {
    const stderr = std.io.getStdErr().writer();
    const argv = try std.process.argsAlloc(hea);
    defer std.process.argsFree(hea, argv);
    if (argv.len > 1) {
        if (std.mem.eql(u8, argv[1], "mono")) {
            if (argv.len != 4)

## kanda_lzs.zig
const std = @import("std");
const mem = std.mem;
const hea = std.heap.page_allocator;

pub fn main() !void {
    const stderr = std.io.getStdErr().writer();

    const argv = try std.process.argsAlloc(hea);
    defer std.process.argsFree(hea, argv);

## README.md

      
              4 files
            
          
              0 forks
            
          
              0 comments
            
          
              0 stars
            
          
                shimamura-sakura
                / README.md
            
            
              Created
              January 1, 2023 06:19
            
          
zig build-exe main.zig
The video must be in resolution 1920 x 1080.
./run.sh video-file
get file "file-out" at current directory


## KandaAlice.md

      
              3 files
            
          
              0 forks
            
          
              0 comments
            
          
              0 stars
            
          
                shimamura-sakura
                / KandaAlice.md
            
            
              Last active
              April 15, 2024 08:07
            
              
                Some research on game "Kanda Alice mo Suiri suru" (神田アリスも推理する)
              
          
    romfs/01_script/*.bin (except info.bin)
(all numbers are in little endian)
file head
first 16 bytes: 0x52, 0x53, 0x34, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00.
then u32: length of instruction part
then u32: length of string part (all strings here)
then u32: length of string indices part (referring the previous table)
then 4 bytes unknown.
	'use strict';

	module.exports = {
	workNextData,
	parseWorkHTML,
	parseEpisodeHTML,
	};

	let lazy_JSDOM = null;
	const std = @import("std");
	const Allocator = std.mem.Allocator;

	pub fn box(allocator: Allocator, value: anytype) !*@TypeOf(value) {
	const ptr = try allocator.create(@TypeOf(value));
	ptr.* = value;
	return ptr;
	}

	test {
	const std = @import("std");

	pub fn StructFieldsTuple(comptime T: type) type {
	var info = switch (@typeInfo(T)) {
	.Struct => \|st\| st,
	else => @compileError("T must be a struct"),
	};
	var newFields = info.fields[0..info.fields.len].*;
	inline for (&newFields, 0..) \|*f, i\| f.name = std.fmt.comptimePrint("{}", .{i});
	info.decls = &.{};
	fn Slice(comptime T: anytype) type {
	return struct {
	const Self = @This();
	const Error = error{EOF};
	left: T,
	pub fn take(self: *Self, n: anytype) Error!@TypeOf(self.left[0..n]) {
	if (self.left.len < n) return Error.EOF;
	defer self.left = self.left[n..];
	return self.left[0..n];
	}
	document.body.onclick = () => {
	document.body.onclick = null;
	navigator.clipboard.writeText(location.href + '\n\n' +
	document.querySelector('article .mod-entry-set').innerText);
	al = document.querySelectorAll('div.entry-bottom-pn>a');
	if (al.length < 3) return alert('no next link');
	window.location = al[2].href;
	};

	// bookmark this:
	const c = @cImport(@cInclude("libdeflate.h"));

	pub const Error = error{
	LibDeflateAlloc,
	LibDeflateBadData,
	LibDeflateShortOutput,
	LibDeflateInsufficientSpace,
	LibDeflateOther,
	};
	const std = @import("std");
	const hea = std.heap.page_allocator;

	pub fn main() anyerror!void {
	const stderr = std.io.getStdErr().writer();
	const argv = try std.process.argsAlloc(hea);
	defer std.process.argsFree(hea, argv);
	if (argv.len > 1) {
	if (std.mem.eql(u8, argv[1], "mono")) {
	if (argv.len != 4)
	const std = @import("std");
	const mem = std.mem;
	const hea = std.heap.page_allocator;

	pub fn main() !void {
	const stderr = std.io.getStdErr().writer();

	const argv = try std.process.argsAlloc(hea);
	defer std.process.argsFree(hea, argv);