text:
@interface ViewController()
@end

struct Matrix rot, rot2, trans, pos, pos1, screen_mat, proj_mat;
struct RenderContext context;
struct Mesh *mesh;
float ang = 0.0f;
CGImageRef image;
NSImage* nsImage;
CVDisplayLinkRef displayLink;
int frames;
NSTimeInterval secs;
NSTimeInterval secs2;

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];

    NSString *path = [[NSBundle mainBundle] pathForResource:  @"f16" ofType: @"obj"];

    mesh = CreateMeshFromFile((char *)path.UTF8String);

    init(&context);
    context.screen_mat = &screen_mat;
    context.proj_mat = &proj_mat;
    context.mv_mat = &pos;

    set_screen_size(&context, 1024, 1024);
    set_hfov(&context, 60.0f);

    ((NovaView*)self.view).context = &context;
    self.view.layer.delegate = self;

    CVDisplayLinkCreateWithActiveCGDisplays(&displayLink);
    CVDisplayLinkSetOutputCallback(displayLink, &DisplayLinkCallback, (__bridge void * _Nullable)(self));
    CVDisplayLinkStart(displayLink);

    [NSTimer scheduledTimerWithTimeInterval:1.0f
    target:self selector:@selector(SetFPSTitle:) userInfo:nil repeats:YES];
}

- (void) SetFPSTitle:(NSTimer *)timer
{
    self.view.window.title = [NSString stringWithFormat:@"fps %d, render %.2f, draw %.2f, pct %.2f", frames, secs, secs2, (secs+secs2) / 0.16];
    frames = 0;
}

CVReturn DisplayLinkCallback(CVDisplayLinkRef displayLink, const CVTimeStamp* now, const CVTimeStamp* outputTime, CVOptionFlags flagsIn, CVOptionFlags* flagsOut, void* displayLinkContext)
{
    NSViewController *controller = (__bridge NSViewController *)(displayLinkContext);
    [controller performSelectorOnMainThread:@selector(redraw) withObject:controller waitUntilDone:false];
    return COREVIDEO_TRUE;
}

- (void)redraw {

    if(self.view.inLiveResize)
        return;

    NSDate* start = [[NSDate alloc] init];

    MatSetRotY(&rot, ang);
    MatSetRotX(&rot2, ang / 2.0f);
    ang -= 0.005f;
    MatSetTranslate(&trans, 0.0f, 0.0f, -5.f);
    MatMul(&rot2, &rot, &pos1);
    MatMul(&trans, &pos1, &pos);

    clear_pixel_buffer(&context);
    clear_depth_buffer(&context);

        render_mesh(&context, mesh);
    secs = [start timeIntervalSinceNow] * -1000;

    [self.view setNeedsDisplay:true];
}

- (void)displayLayer:(CALayer *)theLayer {
    NSDate* start = [[NSDate alloc] init];

    void *src = get_pixel_buffer(&context);

    CFDataRef data = CFDataCreate(NULL, src, context.screen_width * context.screen_height * BYTES_PER_PIXEL);

    CGDataProviderRef provider = CGDataProviderCreateWithCFData(data);
    CGColorSpaceRef color_space = CGColorSpaceCreateDeviceRGB();

    CGImageRef image = CGImageCreate(context.screen_width, context.screen_height, 8, 32, context.screen_width * BYTES_PER_PIXEL, color_space, kCGBitmapByteOrder32Little | kCGImageAlphaNoneSkipFirst, provider, NULL, YES, kCGRenderingIntentDefault);

    theLayer.contents = (__bridge id _Nullable)(image);

    CGImageRelease(image);
    CGColorSpaceRelease(color_space);
    CGDataProviderRelease(provider);
    CFRelease(data);
    frames++;
    secs2 = [start timeIntervalSinceNow] * -1000;

}
@end


text:
/**
 * @module server
 */
/** End Typedoc Module Declaration */
import { Database } from '../services/database.service';
import { Logger } from '../../common/services/logger.service';
/**
 * Root class that all implementations of seeders *must* extend. Provides common interface for
 * bootstrapper to handle seeding
 */
export abstract class AbstractMigration {

  protected logger:Logger;
  constructor(loggerBase:Logger, protected database:Database){
    this.logger = loggerBase.source(this.constructor.name);
  }

  /**
   * Starts the migration. Returns promise so bootstrapper can wait until finished before starting
   * the next migration
   */
  public abstract migrate():Promise<void>;

  /**
   * Reverts the migration. Returns promise so bootstrapper can wait until finished before rolling
   * back the next migration
   */
  public abstract rollback():Promise<void>;

}

redpajama_set_name: RedPajamaGithub


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Voodoo.CodeGeneration.Helpers;
using Voodoo.CodeGeneration.Models;
using Voodoo.CodeGeneration.Models.Reflection;
using Voodoo.CodeGeneration.Models.VisualStudio;

namespace Voodoo.CodeGeneration.Templates.Logic.OperationLevel.Extras
{
    public class DetailFile : TypedCodeFile
    {
        public DetailFile(ProjectFacade project, TypeFacade type)
            : base(project, type)
        {

            PageSpecificUsingStatements.Add("Voodoo.Validation");
            Name = $"{Name}Detail";
            PageSpecificUsingStatements.Add(type.Namespace);

            PageSpecificUsingStatements.Add("System");
            PageSpecificUsingStatements.Add("System.Collections.Generic");
            PageSpecificUsingStatements.Add("System.ComponentModel.DataAnnotations");
            PageSpecificUsingStatements.Add("System.Linq");
            PageSpecificUsingStatements.Add("Voodoo.Messages");
            PageSpecificUsingStatements.Add("Voodoo.Infrastructure.Notations");

            type.Properties.ForEach(c => PageSpecificUsingStatements.Add(c.PropertyType.Namespace));
        }
        public override string GetFileContents()
        {
            var output = new StringBuilder();
            foreach (var item in UsingStatements) {
                output.AppendLine($"using {item};");
            }
            output.AppendLine($"namespace {Namespace}");
            output.AppendLine("{");
            output.AppendLine($"public class {Type.DetailMessageName}");
            output.AppendLine("{");
            foreach (var item in Type.DetailMessageProperties) {
                foreach (var attr in item.Property.Attributes) {
                    output.AppendLine(attr.Text);
                }
                output.AppendLine($"public {item.StringifiedTypeName} {item.PropertyName} {{get;set;}}");
                output.AppendLine();
            }
            output.AppendLine("}");
            output.AppendLine("}");
            var code = CodeFormatter.Format(output.ToString());
            return code;
    }

        public override string GetFolder()
        {
            return $@"Operations\{ExtrasFolder}";
        }
    }
}


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace FormsWrapper.GUI
{
    public partial class Menu
    {
        public enum FormType {
            gridForm = 1,
            freeForm = 2,
        }

        public Menu(FormType ft) {
            //System.Windows.Forms.Form asd;
        }
        public Menu() { }

        public static void addToForm(ElementType et) { }
        public static void fill(Content content) { }

        public static void parseCSS(string cssFile) { }
        public static void parseBatch() { }

        public static void showForm() { }
        public static void showDialog() { }
        public static void showballoonTip() { }
        public TUI.Menu toGUI() {
            return new TUI.Menu();
        }

    }
}