clinuxrulz

function ProcessFile {
    param(
        [string]$inputFilename,
        [string]$outputFilename
    )

    $csv = @()
    $sr = New-Object System.IO.StreamReader($inputFilename)
    try {
        while ($true) {

clinuxrulz

Add-Type -ReferencedAssemblies ("Microsoft.Office.Interop.Excel") -TypeDefinition @"
using System;
using System.Collections.Generic;
using Excel = Microsoft.Office.Interop.Excel;

public static class Program {
    public static void Main(string[] args) {
        if (args.Length != 2) {
            Console.WriteLine("Please pass input file name and output file name as arguments.");
            return;

clinuxrulz

export class Plugin {
    private src: String;
    private callbacks: any;
    private iframe?: HTMLIFrameElement;
    private messageHandler: (e: MessageEvent) => void;
    private recvMsgHandler: (msg: string) => void;
    private nextCallId: number = 0;
    private resolveMap: any;
    
    onLoad: () => void = () => {};

clinuxrulz

module Main where

import Prelude (Unit, ($), (+), (<>), (<$>), (<*>), (==), (>), discard)
import Effect (Effect)
import Effect.Console (log)
import Control.Category
import Control.Semigroupoid
import Data.Leibniz
import Data.Maybe
import Data.Exists

clinuxrulz

import { Vec2 } from "../math/Vec2";
import { Result, err, ok } from "./Result";

export type PropertiesSchema<A> = PropertiesSchemaInvMap<unknown,A> | PropertiesSchema2<A>;

type PropertiesSchemaInvMap<A,B> = {
    type: "InvMap",
    propertiesSchema: PropertiesSchema<A>,
    fn1: (a: A) => B,
    fn2: (b: B) => A,

clinuxrulz

use std::cell::{Cell, RefCell};
use std::rc::{Rc, Weak};
use std::ops::{Deref, DerefMut};

pub struct FgrCtx {
    observer: Rc<Node>,
    dirty_nodes: Vec<Rc<Node>>,
    transaction_depth: usize,
}

clinuxrulz

import { batch, Component, createEffect, createMemo, onCleanup, onMount } from 'solid-js';
import { createStore } from 'solid-js/store';

const Window: Component<{
    title?: string,
    width?: number,
    height?: number,
    initX?: number,
    initY?: number,
}> = (props) => {

clinuxrulz

#[derive(Debug, PartialEq, Eq)]
pub enum ChunkNextResult {
    Empty,
    Char(char),
    Eof,
}

pub struct Chunk<'a> {
    next: Box<dyn FnMut()->ChunkNextResult+'a>,
    unnext_stack: Vec<char>,

clinuxrulz

use std::cell::RefCell;
use std::collections::HashSet;
use std::hash::{Hash, Hasher};
use std::rc::Rc;

thread_local! {
    static STRING_FACTORY: RefCell<StringFactory> = RefCell::new(StringFactory::new());
}

struct MyRc<A>(Rc<A>);

clinuxrulz

module Main where

import Prelude
import Data.Array.ST as STArray
import Control.Monad.Eff.Console (log) as Console
import Control.Monad.Eff (runPure, Eff)
import Control.Monad.Rec.Class (tailRecM)
import Control.Monad.ST (newSTRef, runST, readSTRef, writeSTRef, ST, STRef)
import Data.Array.ST (pushSTArray, emptySTArray, STArray)
import Data.Either (either, Either(Left, Right))