hexsha stringlengths 40 40 | size int64 5 1.05M | ext stringclasses 588
values | lang stringclasses 305
values | max_stars_repo_path stringlengths 3 363 | max_stars_repo_name stringlengths 5 118 | max_stars_repo_head_hexsha stringlengths 40 40 | max_stars_repo_licenses listlengths 1 10 | max_stars_count float64 1 191k ⌀ | max_stars_repo_stars_event_min_datetime stringdate 2015-01-01 00:00:35 2022-03-31 23:43:49 ⌀ | max_stars_repo_stars_event_max_datetime stringdate 2015-01-01 12:37:38 2022-03-31 23:59:52 ⌀ | max_issues_repo_path stringlengths 3 363 | max_issues_repo_name stringlengths 5 118 | max_issues_repo_head_hexsha stringlengths 40 40 | max_issues_repo_licenses listlengths 1 10 | max_issues_count float64 1 134k ⌀ | max_issues_repo_issues_event_min_datetime stringlengths 24 24 ⌀ | max_issues_repo_issues_event_max_datetime stringlengths 24 24 ⌀ | max_forks_repo_path stringlengths 3 363 | max_forks_repo_name stringlengths 5 135 | max_forks_repo_head_hexsha stringlengths 40 40 | max_forks_repo_licenses listlengths 1 10 | max_forks_count float64 1 105k ⌀ | max_forks_repo_forks_event_min_datetime stringdate 2015-01-01 00:01:02 2022-03-31 23:27:27 ⌀ | max_forks_repo_forks_event_max_datetime stringdate 2015-01-03 08:55:07 2022-03-31 23:59:24 ⌀ | content stringlengths 5 1.05M | avg_line_length float64 1.13 1.04M | max_line_length int64 1 1.05M | alphanum_fraction float64 0 1 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
8f62e4384e901882fa9df7ccfc44251af0ef49da | 1,271 | zig | Zig | opaquetype/opaquetype.zig | winksaville/zig-explore | 34a19e1540a3b1a3e72c4d0ed339cd0384c0760e | [
"Unlicense"
] | 5 | 2018-10-15T18:52:38.000Z | 2021-12-22T02:37:01.000Z | opaquetype/opaquetype.zig | winksaville/zig-explore | 34a19e1540a3b1a3e72c4d0ed339cd0384c0760e | [
"Unlicense"
] | null | null | null | opaquetype/opaquetype.zig | winksaville/zig-explore | 34a19e1540a3b1a3e72c4d0ed339cd0384c0760e | [
"Unlicense"
] | null | null | null | const assert = @import("std").debug.assert;
// So a type with just a single variant an opaque pointer
// works fine.
const S = struct {
const Self = @This();
value: u32,
fn getValue(pOpaqueSelf: OpaquePtr()) u32 {
var pSelf = @ptrCast(*Self, pOpaqueSelf);
return pSelf.value;
}
/// OpaquePtr to S with appropriate alignment
fn OpaquePtr() type {
return (*align(@alignOf(S)) @OpaqueType());
}
};
test "Opaquetype Single Variant" {
var s = S {
.value = 1,
};
var pS = &s;
assert(pS.value == 1);
assert(S.getValue(@ptrCast(S.OpaquePtr(), pS)) == 1);
}
fn V(comptime T: type) type {
return struct {
const Self = @This();
value: T,
fn getValue(pOpaqueSelf: OpaquePtr()) u32 {
var pSelf = @ptrCast(*Self, pOpaqueSelf);
return pSelf.value;
}
/// OpaquePtr to V with appropriate alignment
fn OpaquePtr() type {
return *align(@alignOf(Self)) @OpaqueType();
}
};
}
test "Opaquetype Multi-Variant" {
var v = V(u32) {
.value = 1,
};
var pV = &v;
assert(pV.value == 1);
var pOpaqueV = @ptrCast(V(u32).OpaquePtr(), pV);
assert(V(u32).getValue(pOpaqueV) == 1);
}
| 21.913793 | 57 | 0.552321 |
2514bed90100278d9a2a4410108f9258fbcfe7ef | 1,839 | zig | Zig | types.zig | igmanthony/zig_comptime_lisp | 67ac465a345629311f6aa96c0de1f3c698fa3964 | [
"Unlicense"
] | 15 | 2021-03-14T19:11:08.000Z | 2021-09-06T07:55:09.000Z | types.zig | igmanthony/zig_comptime_lisp | 67ac465a345629311f6aa96c0de1f3c698fa3964 | [
"Unlicense"
] | null | null | null | types.zig | igmanthony/zig_comptime_lisp | 67ac465a345629311f6aa96c0de1f3c698fa3964 | [
"Unlicense"
] | null | null | null | const std = @import("std");
const eval = @import("eval.zig");
const Env = eval.Env;
const SinglyLinkedList = std.SinglyLinkedList;
pub const AtomList = SinglyLinkedList(Atom);
pub const VarList = SinglyLinkedList(Variable);
pub const SpecialForms = enum {
def,
@"if",
@"fn",
};
// errors rock with comptime... partly because print debugging isn't very helpful :)
pub const SyntaxErrors = error{
InvalidParseToken,
FoundRParensInParse,
EndOfTokenList,
ParsingUnreachable,
NoFunctionFound,
CannotApplyFunction,
IndexEqualTokenCount,
CannotFindKeyInEnvs,
UserFunctionParameterArgumentLengthMismatch,
InvalidFunctionArgsOrBody,
NoDefKeyword,
NoDefinedValue,
NoFunctionShouldBeHere,
SomethingFellThroughTheEvalCracks,
KeyDisappearedAfterFinding,
};
pub const Variable = struct {
name: []const u8,
value: Value,
};
pub const Value = union(enum) {
atom: Atom,
func: Func,
};
/// this is a bad name for what it represents... I'm just not sure what's better... "Type" seems
/// worse. This is the "basetype" (too long of a name) for this toy language
pub const Atom = union(enum) {
number: f64,
list: AtomList,
keyword: []const u8,
function: *const Function,
};
/// Union of function pointer types with different numbers of input parameters. Not sure of a better
/// way to do this -> I took inspiration from the MAL implementation on:
/// github.com/kanaka/mal/tree/master/impls/zig
/// also, func can't be an atom, as it would depend on atom
pub const Func = union(enum) {
funcZero: *const fn () Atom,
funcOne: *const fn (first: Atom) Atom,
funcTwo: *const fn (first: Atom, second: Atom) Atom,
funcUser: *const Function,
};
pub const Function = struct {
args: AtomList,
body: AtomList,
env: *Env,
};
| 26.652174 | 101 | 0.690593 |
b2e5fcabb5b9ecc9ef32a8e311188a10feb0d0f3 | 513 | zig | Zig | src/main.zig | mattnite/download | 72ef813269e7d69559f2d166c925aa5736a5bce6 | [
"MIT"
] | null | null | null | src/main.zig | mattnite/download | 72ef813269e7d69559f2d166c925aa5736a5bce6 | [
"MIT"
] | 1 | 2021-06-21T02:57:59.000Z | 2021-06-21T02:57:59.000Z | src/main.zig | mattnite/download | 72ef813269e7d69559f2d166c925aa5736a5bce6 | [
"MIT"
] | 1 | 2021-06-20T18:56:05.000Z | 2021-06-20T18:56:05.000Z | const std = @import("std");
pub const tar = @import("tar.zig");
pub const Options = struct {
/// override hashed url with a name, warning that this could collide
name: ?[]const u8 = null,
/// integrity check using sha256
sha256: ?[]const u8 = null,
};
test "tar.gz" {
const path = try tar.gz(
std.testing.allocator,
"zig-cache",
"https://www.sqlite.org/snapshot/sqlite-snapshot-202103011616.tar.gz",
.{},
);
defer std.testing.allocator.free(path);
}
| 24.428571 | 78 | 0.608187 |
0af076d40acfd848a05f6785243eeaecd2b56351 | 418 | zig | Zig | test/stage1/behavior/fn_in_struct_in_comptime.zig | Aversiste/zig | 20e2d8da616aa6406572e64274fec0740cb626c6 | [
"MIT"
] | null | null | null | test/stage1/behavior/fn_in_struct_in_comptime.zig | Aversiste/zig | 20e2d8da616aa6406572e64274fec0740cb626c6 | [
"MIT"
] | null | null | null | test/stage1/behavior/fn_in_struct_in_comptime.zig | Aversiste/zig | 20e2d8da616aa6406572e64274fec0740cb626c6 | [
"MIT"
] | 1 | 2019-05-13T17:35:42.000Z | 2019-05-13T17:35:42.000Z | const assertOrPanic = @import("std").debug.assertOrPanic;
fn get_foo() fn (*u8) usize {
comptime {
return struct {
fn func(ptr: *u8) usize {
var u = @ptrToInt(ptr);
return u;
}
}.func;
}
}
test "define a function in an anonymous struct in comptime" {
const foo = get_foo();
assertOrPanic(foo(@intToPtr(*u8, 12345)) == 12345);
}
| 23.222222 | 61 | 0.535885 |
3a2f8a0a8a7fe0bf371be91341d23eefb7d725e2 | 1,563 | zig | Zig | test/behavior/bitcast.zig | courajs/zig | ee98d8700818aa667137e3aa580b16df2ba6d680 | [
"MIT"
] | null | null | null | test/behavior/bitcast.zig | courajs/zig | ee98d8700818aa667137e3aa580b16df2ba6d680 | [
"MIT"
] | null | null | null | test/behavior/bitcast.zig | courajs/zig | ee98d8700818aa667137e3aa580b16df2ba6d680 | [
"MIT"
] | null | null | null | const std = @import("std");
const builtin = @import("builtin");
const expect = std.testing.expect;
const expectEqual = std.testing.expectEqual;
const maxInt = std.math.maxInt;
const native_endian = builtin.target.cpu.arch.endian();
test "@bitCast i32 -> u32" {
try testBitCast_i32_u32();
comptime try testBitCast_i32_u32();
}
fn testBitCast_i32_u32() !void {
try expect(conv(-1) == maxInt(u32));
try expect(conv2(maxInt(u32)) == -1);
}
fn conv(x: i32) u32 {
return @bitCast(u32, x);
}
fn conv2(x: u32) i32 {
return @bitCast(i32, x);
}
test "bitcast result to _" {
_ = @bitCast(u8, @as(i8, 1));
}
test "nested bitcast" {
const S = struct {
fn moo(x: isize) !void {
try expect(@intCast(isize, 42) == x);
}
fn foo(x: isize) !void {
try @This().moo(
@bitCast(isize, if (x != 0) @bitCast(usize, x) else @bitCast(usize, x)),
);
}
};
try S.foo(42);
comptime try S.foo(42);
}
test "@bitCast enum to its integer type" {
const SOCK = enum(c_int) {
A,
B,
fn testBitCastExternEnum() !void {
var SOCK_DGRAM = @This().B;
var sock_dgram = @bitCast(c_int, SOCK_DGRAM);
try expect(sock_dgram == 1);
}
};
try SOCK.testBitCastExternEnum();
comptime try SOCK.testBitCastExternEnum();
}
// issue #3010: compiler segfault
test "bitcast literal [4]u8 param to u32" {
const ip = @bitCast(u32, [_]u8{ 255, 255, 255, 255 });
try expect(ip == maxInt(u32));
}
| 23.328358 | 88 | 0.575176 |
c63af066fb12b816c129d43dd3da612bed50370b | 35,199 | zig | Zig | src/bibtex.zig | omgitsmoe/SciMarkdown | 975fe80599f07f29a045015e49e6cd25ec0e043a | [
"MIT"
] | null | null | null | src/bibtex.zig | omgitsmoe/SciMarkdown | 975fe80599f07f29a045015e49e6cd25ec0e043a | [
"MIT"
] | null | null | null | src/bibtex.zig | omgitsmoe/SciMarkdown | 975fe80599f07f29a045015e49e6cd25ec0e043a | [
"MIT"
] | null | null | null | // names all say bibtex but this is a biblatex parser
const std = @import("std");
const utils = @import("utils.zig");
const expect = std.testing.expect;
const log = std.log;
pub const BibParser = struct {
bib: Bibliography,
idx: u32,
bytes: []const u8,
allocator: *std.mem.Allocator,
pub const Error = error {
SyntaxError,
OutOfMemory,
EndOfFile,
DuplicateLabel,
};
pub fn init(allocator: *std.mem.Allocator, path: []const u8, bytes: []const u8) BibParser {
var parser = BibParser{
.bib = Bibliography{
.path = path,
.label_entry_map = std.StringHashMap(Entry).init(allocator),
.field_arena = std.heap.ArenaAllocator.init(allocator),
},
.idx = 0,
.bytes = bytes,
.allocator = allocator,
};
return parser;
}
inline fn report_error(comptime err_msg: []const u8, args: anytype) void {
log.err(err_msg, args);
}
// zig stdlib's reader also returns EndOfStream err instead of returning null
// prob since ?u8 is actually u9 (1 extra bit for maybe bool)
// but !u8 returns a union with a value: u8 field and a tag field
// which is 0 (none) if there is no error otherwise it's the error code e.g. EndOfFile(51)
// so this would require even more space? (all irrelevant anyway since it will fit in a
// register, but I just wanna know how it works)
inline fn advance_to_next_byte(self: *BibParser) Error!void {
if (self.idx + 1 < self.bytes.len) {
self.idx += 1;
} else {
return Error.EndOfFile;
}
}
inline fn peek_byte(self: *BibParser) u8 {
// current position must be in bounds since we should've hit Error.EndOfFile otherwise
return self.bytes[self.idx];
}
inline fn eat_until(self: *BibParser, end: u8) Error!void {
while (self.peek_byte() != end) {
self.advance_to_next_byte() catch {
BibParser.report_error("Reached EOF while waiting for '{c}'!\n", .{ end });
return Error.EndOfFile;
};
}
}
fn eat_name(self: *BibParser) Error!void {
var byte = self.peek_byte();
while (true) {
switch (byte) {
// this is what btparse defines as name, but are that many special chars allowed?
// biber disallows " # ' ( ) , = { } %
'a'...'z', 'A'...'Z', '0'...'9',
'!', '$', '*', '+', '-', '.', '/', ':',
';', '<', '>', '?', '[', ']', '^', '_', '`', '|' => {},
else => break,
}
self.advance_to_next_byte() catch {
BibParser.report_error("Reached EOF while consuming name!\n", .{});
return Error.EndOfFile;
};
byte = self.peek_byte();
}
}
/// does not advance the idx
inline fn require_byte(self: *BibParser, byte: u8) Error!void {
if (self.peek_byte() != byte) {
BibParser.report_error("Expected '{c}' got '{c}'!\n", .{ byte, self.peek_byte() });
return Error.SyntaxError;
}
}
inline fn eat_byte(self: *BibParser, byte: u8) Error!void {
try self.require_byte(byte);
try self.advance_to_next_byte();
}
fn next(self: *BibParser) ?u8 {
if (self.idx + 1 < self.bytes.len) {
self.idx += 1;
var byte = self.bytes[self.idx];
return byte;
} else {
return null;
}
}
inline fn reached_eof(self: *BibParser) bool {
if (self.idx >= self.bytes.len) {
return true;
} else {
return false;
}
}
/// caller owns memory of return Bibliography
pub fn parse(self: *BibParser) Error!Bibliography {
// clean up on error so we don't leak on unsuccessful parses
errdefer {
self.bib.deinit();
}
while (self.idx < self.bytes.len) {
var byte = self.peek_byte();
if (utils.is_whitespace(byte)) {
self.idx += 1;
continue;
}
switch (byte) {
'@' => {
self.idx += 1;
try self.parse_entry();
},
'%' => {
// line-comment, used by jabref to state encoding
self.idx += 1;
self.skip_line();
},
else => {
BibParser.report_error(
"Unexpected byte '{c}' expected either '@' followed by a valid " ++
" entry type or '%' to start a line comment!\n", .{ byte });
return Error.SyntaxError;
},
}
}
return self.bib;
}
fn skip_line(self: *BibParser) void {
var byte: u8 = undefined;
while (self.idx < self.bytes.len) : (self.idx += 1) {
byte = self.bytes[self.idx];
if (byte == '\r') {
// macos classic line ending is just \r
self.idx += 1;
if (self.idx < self.bytes.len and self.bytes[self.idx] == '\n') {
self.idx += 1;
}
break;
} else if (byte == '\n') {
// unix line-ending
self.idx += 1;
break;
}
}
}
fn skip_whitespace(self: *BibParser, comptime eof_is_error: bool) Error!void {
while (utils.is_whitespace(self.peek_byte())) {
self.advance_to_next_byte() catch {
BibParser.report_error("Hit EOF while skipping whitespace!\n", .{});
return Error.EndOfFile;
};
}
}
fn parse_entry(self: *BibParser) Error!void {
const entry_type_start = self.idx;
while (self.peek_byte() != '{') {
self.advance_to_next_byte() catch {
BibParser.report_error("Reached EOF while parsing entry type name!\n", .{});
return Error.SyntaxError;
};
}
// convert to lower-case to match with enum tagNames
const lowercased = try std.ascii.allocLowerString(
self.allocator, self.bytes[entry_type_start..self.idx]);
const entry_type = std.meta.stringToEnum(
EntryType, lowercased) orelse {
BibParser.report_error("'{s}' is not a valid entry type!\n",
.{ self.bytes[entry_type_start..self.idx] });
return Error.SyntaxError;
};
self.allocator.free(lowercased);
if (entry_type == .comment) {
// NOTE: not allowing {} inside comments atm
try self.eat_until('}');
// TODO @Improve
self.advance_to_next_byte() catch {
// advance_to_next_byte errors since we're at the last byte before EOF
// but we know the current one is '{' so we advance it manually
// so the main loop in parse can exit properly
self.idx += 1;
return;
};
return;
}
try self.advance_to_next_byte();
const label_start = self.idx;
// TODO allow unicode labels?
try self.eat_name();
try self.require_byte(',');
const label = self.bytes[label_start..self.idx];
// make sure we don't have a duplicate label!
var entry_found = try self.bib.label_entry_map.getOrPut(label);
// ^ result will be a struct with a pointer to the HashMap.Entry and a bool
// whether an existing value was found
if (entry_found.found_existing) {
BibParser.report_error("Duplicate label '{s}'!\n", .{ label });
return Error.DuplicateLabel;
} else {
// actually write entry value (key was already written by getOrPut)
entry_found.value_ptr.* = Entry.init(&self.bib.field_arena.allocator, entry_type);
}
try self.advance_to_next_byte();
var byte: u8 = undefined;
while (!self.reached_eof()) {
try self.skip_whitespace(true);
byte = self.bytes[self.idx];
if (byte == '}') {
self.advance_to_next_byte() catch {
self.idx += 1;
return;
};
break;
} else {
// NOTE: label_entry_map can't be modified while the function below is
// still running otherwise the entry ptr might? get invalidated
try self.parse_entry_field(entry_found.value_ptr);
}
}
}
/// expects to start on first byte of field name
fn parse_entry_field(self: *BibParser, entry: *Entry) Error!void {
const field_name_start = self.idx;
try self.eat_name();
const field_name_end = self.idx;
// convert to lower-case to match with enum tagNames
const lowercased = try std.ascii.allocLowerString(
self.allocator, self.bytes[field_name_start..field_name_end]);
const field_name = std.meta.stringToEnum(FieldName, lowercased) orelse .custom;
self.allocator.free(lowercased);
try self.skip_whitespace(true);
try self.eat_byte('=');
try self.skip_whitespace(true);
// TODO worth to handle field values that are not wrapped in {} and those
// that are wrapped in "" and thus can be concatenated using '#'?
self.eat_byte('{') catch {
BibParser.report_error(
"This implementation of a bibtex parser requires all field values to " ++
"be wrapped in {{braces}}!\n", .{});
return Error.SyntaxError;
};
// need to reform field value string since it might contain braces and other
// escapes
var field_value_str = std.ArrayList(u8).init(&self.bib.field_arena.allocator);
var braces: u32 = 0;
// TODO foreign/special char escapes e.g. \'{o} for ó etc.
// currently just discards the braces
// TODO process into name lists etc.
// TODO {} protect from case-mangling etc.
var byte = self.peek_byte();
var added_until = self.idx; // exclusive
while (true) {
switch (byte) {
'{' => {
braces += 1;
try field_value_str.appendSlice(self.bytes[added_until..self.idx]);
added_until = self.idx + 1; // +1 so we don't add the {
},
'}' => {
if (braces == 0) {
try field_value_str.appendSlice(self.bytes[added_until..self.idx]);
break;
} else {
braces -= 1;
try field_value_str.appendSlice(self.bytes[added_until..self.idx]);
added_until = self.idx + 1; // +1 so we don't add the }
}
},
'\\' => {
try field_value_str.appendSlice(self.bytes[added_until..self.idx]);
try self.advance_to_next_byte();
byte = self.peek_byte();
try field_value_str.append(byte);
added_until = self.idx + 1;
},
else => {},
}
try self.advance_to_next_byte();
byte = self.peek_byte();
}
try self.eat_byte('}');
// , is technichally optional
if (self.peek_byte() == ',') {
try self.advance_to_next_byte();
}
// std.debug.print("Field -> {s}: {s}\n",
// .{ self.bytes[field_name_start..field_name_end], field_value_str.items });
const field_type = field_name.get_field_type();
// payload will be undefined after from_field_tag
var field_value = FieldType.from_field_tag(field_type);
switch (field_value) {
.name_list, .literal_list, .key_list => |*value| {
// NOTE: the split list still uses the memory of field_value_str
// so we can't free it
value.*.values = try BibParser.split_list(
&self.bib.field_arena.allocator, field_value_str.toOwnedSlice());
},
.literal_field, .range_field, .integer_field, .datepart_field, .date_field,
.verbatim_field, .uri_field, .separated_value_field, .pattern_field,
.key_field, .code_field, .special_field, => |*value| {
value.*.value = field_value_str.toOwnedSlice();
},
}
// not checking if field already present -> gets overwritten
try entry.fields.put(
self.bytes[field_name_start..field_name_end],
Field{
.name = field_name,
.data = field_value,
}
);
}
inline fn split_list(allocator: *std.mem.Allocator, bytes: []const u8) Error![]const []const u8 {
// NOTE: not checking keys of key lists
// NOTE: leaving names of name lists as-is and parsing them on demand
// with ListField.parse_name
var split_items = std.ArrayList([]const u8).init(allocator);
var split_iter = std.mem.split(bytes, " and ");
while (split_iter.next()) |item| {
try split_items.append(item);
}
return split_items.toOwnedSlice();
}
};
test "split list" {
const alloc = std.testing.allocator;
var res = try BibParser.split_list(alloc, "A and B and C and others");
var expected = [_][]const u8 { "A", "B", "C", "others" };
for (res) |it, i| {
try expect(std.mem.eql(u8, it, expected[i]));
}
// otherwise testing allocator complains about memory leak
alloc.free(res);
res = try BibParser.split_list(alloc, "Hand and von Band, Jr., Test and Stand de Ipsum and others");
expected = [_][]const u8 { "Hand", "von Band, Jr., Test", "Stand de Ipsum", "others" };
for (res) |it, i| {
try expect(std.mem.eql(u8, it, expected[i]));
}
alloc.free(res);
}
test "bibparser" {
const alloc = std.testing.allocator;
const bibtxt =
\\% Encoding: UTF-8
\\@Article{Seidel2015,
\\author = {{Dominik} {Seidel} and {Nils Hoffmann} and Martin Ehbrecht and Julia Juchheim and Christian Ammer},
\\title = {{How} neighborhood affects tree diameter increment},
\\journal = {Forest Ecology and Management},
\\year = {2015},
\\volume = {336},
\\pages = {119--128},
\\month = {jan},
\\doi = {10.1016/j.foreco.2014.10.020},
\\file = {:../Lit/Seidel et al. 2015_as downloaded.pdf:PDF},
\\publisher = {Elsevier {BV}},
\\}
\\@Comment{jabref-meta: databaseType:bibtex;}
;
var bp = BibParser.init(alloc, "/home/test/path", bibtxt);
var bib = try bp.parse();
defer bib.deinit();
try expect(std.mem.eql(u8, bib.path, "/home/test/path"));
var entry = bib.label_entry_map.get("Seidel2015").?;
try expect(entry._type == .article);
const author = entry.fields.get("author").?;
const author_expected = [_][]const u8 {
"Dominik Seidel", "Nils Hoffmann", "Martin Ehbrecht", "Julia Juchheim", "Christian Ammer"
};
for (author.data.name_list.values) |it, i| {
try expect(std.mem.eql(u8, it, author_expected[i]));
}
var field = entry.fields.get("title").?;
try expect(std.mem.eql(
u8, field.data.literal_field.value, "How neighborhood affects tree diameter increment"));
field = entry.fields.get("journal").?;
try expect(std.mem.eql(
u8, field.data.literal_field.value, "Forest Ecology and Management"));
field = entry.fields.get("year").?;
try expect(std.mem.eql(
u8, field.data.literal_field.value, "2015"));
field = entry.fields.get("volume").?;
try expect(std.mem.eql(
u8, field.data.integer_field.value, "336"));
field = entry.fields.get("pages").?;
try expect(std.mem.eql(
u8, field.data.range_field.value, "119--128"));
field = entry.fields.get("month").?;
try expect(std.mem.eql(
u8, field.data.literal_field.value, "jan"));
field = entry.fields.get("doi").?;
try expect(std.mem.eql(
u8, field.data.verbatim_field.value, "10.1016/j.foreco.2014.10.020"));
field = entry.fields.get("publisher").?;
try expect(field.data.literal_list.values.len == 1);
try expect(std.mem.eql(u8, field.data.literal_list.values[0], "Elsevier BV"));
}
test "bibparser no leak on err" {
const alloc = std.testing.allocator;
const bibtxt =
\\% Encoding: UTF-8
\\@Article{Seidel2015,
;
var bp = BibParser.init(alloc, "/home/test/path", bibtxt);
var bib = bp.parse();
try std.testing.expectError(BibParser.Error.EndOfFile, bib);
}
pub const FieldMap = std.StringHashMap(Field);
pub const Bibliography = struct {
path: []const u8,
label_entry_map: std.StringHashMap(Entry),
field_arena: std.heap.ArenaAllocator,
pub fn deinit(self: *Bibliography) void {
self.label_entry_map.deinit();
self.field_arena.deinit();
}
};
// could use std.meta.TagPayloadType to get payload type from tag on a tagged union
pub const FieldTypeTT = std.meta.TagType(FieldType);
pub const FieldType = union(enum) {
// lists
// all lists can be shortened with 'and others'
// in case of name_list it will then always print et al. in the bibliography
name_list: ListField,
literal_list: ListField,
key_list: ListField,
// fields
literal_field: SingleField,
range_field: SingleField,
integer_field: SingleField,
datepart_field: SingleField,
date_field: SingleField,
verbatim_field: SingleField,
uri_field: SingleField,
separated_value_field: SingleField,
pattern_field: SingleField,
key_field: SingleField,
code_field: SingleField,
special_field: SingleField,
/// returns union with correct tag activated based on it's tag type
/// NOTE: the payload type will be undefined!
pub fn from_field_tag(tag: FieldTypeTT) FieldType {
return switch (tag) {
.name_list => FieldType{ .name_list = undefined },
.literal_list => FieldType{ .literal_list = undefined },
.key_list => FieldType{ .key_list = undefined },
.literal_field => FieldType{ .literal_field = undefined },
.range_field => FieldType{ .range_field = undefined },
.integer_field => FieldType{ .integer_field = undefined },
.datepart_field => FieldType{ .datepart_field = undefined },
.date_field => FieldType{ .date_field = undefined },
.verbatim_field => FieldType{ .verbatim_field = undefined },
.uri_field => FieldType{ .uri_field = undefined },
.separated_value_field => FieldType{ .separated_value_field = undefined },
.pattern_field => FieldType{ .pattern_field = undefined },
.key_field => FieldType{ .key_field = undefined },
.code_field => FieldType{ .code_field = undefined },
.special_field => FieldType{ .special_field = undefined },
};
}
};
pub const ListField = struct {
values: []const []const u8,
pub const Name = struct {
last: ?[]const u8 = null,
first: ?[]const u8 = null,
prefix: ?[]const u8 = null,
suffix: ?[]const u8 = null,
const unkown_format_err = "Name has unkown format{s}!\n" ++
"Formats are:\n" ++
"First von Last\n" ++
"von Last, First\n" ++
"von Last, Jr, First\n";
};
const NameState = enum {
first,
prefix,
suffix,
last,
};
/// doesn't recognize lowercase unicode codepoints which is need for identifying
/// the prefix part of the Name
pub fn parse_name(name: []const u8) BibParser.Error!Name {
// 4 name components:
// Family name (also known as 'last' part)
// Given name (also known as 'first' part)
// Name prefix (also known as 'von' part)
// Name suffix (also known as 'Jr' part)
// the name can be typed in one of 3 forms:
// "First von Last"
// "von Last, First"
// "von Last, Jr, First"
var commas: u8 = 0;
for (name) |c| {
if (c == ',') {
commas += 1;
}
}
switch (commas) {
0 => return parse_name_simple(name),
1, 2 => return parse_name_with_commas(name, commas),
// technichally this should remove the extra commas >2
else => return parse_name_with_commas(name, commas),
}
return result;
}
fn parse_name_simple(name: []const u8) BibParser.Error!Name {
// words split by whitespace
// up to first lowercase word is 'first'
// all following lowercase words are 'prefix'
// first uppercase word starts 'last'
// no suffix part
var result = Name{};
var state = NameState.first;
var i: u16 = 0;
var last_end: u16 = 0; // exclusive
var last_word_start: u16 = 0; // inclusive
var prev_whitespace = false;
while (i < name.len) : ( i += 1 ) {
if (utils.is_whitespace(name[i])) {
prev_whitespace = true;
// to skip initial whitespace
if (i == last_end) {
last_end += 1;
}
} else if (prev_whitespace) {
switch (name[i]) {
'a'...'z' => {
switch (state) {
.first => {
state = .prefix;
// -1 to not include last space
result.first = name[last_end..i-1];
last_end = i;
},
else => {}
}
},
'A'...'Z' => {
switch (state) {
.prefix => {
state = .last;
// -1 to not include last space
result.prefix = name[last_end..i-1];
last_end = i;
},
else => {},
}
},
else => {},
}
prev_whitespace = false;
last_word_start = i;
}
}
// no words starting with a lowercase letter -> no prefix
// btparse then just treats the whole string as first
// but biblatex seems to interpret First Last correctly
if (state == .first) {
if (last_word_start != 0) {
result.first = name[0..last_word_start - 1];
result.last = name[last_word_start..];
} else {
result.last = name[0..];
}
} else {
result.last = name[last_end..];
}
return result;
}
fn parse_name_with_commas(name: []const u8, num_commas: u8) BibParser.Error!Name {
var result = Name{};
var state = NameState.prefix;
var last_end: u16 = 0; // exclusive
var i: u16 = 0;
var prev_whitespace = false;
while (i < name.len) : ( i += 1) {
if (utils.is_whitespace(name[i])) {
prev_whitespace = true;
// to skip initial whitespace
if (i == last_end) {
last_end += 1;
}
} else if (prev_whitespace) {
switch (name[i]) {
// 'a'...'z' => {
// },
'A'...'Z' => {
if (state == .prefix) {
state = .last;
if (last_end != i) {
result.prefix = name[last_end..i-1];
last_end = i;
}
}
},
else => {},
}
prev_whitespace = false;
}
switch (name[i]) {
',' => {
switch (state) {
.last, .prefix => {
// prefix:
// only lowercase words so far but comma would now start first/suffix
// treat everything up to here as last
state = if (num_commas < 2) .first else .suffix;
result.last = name[last_end..i];
last_end = i + 1; // skip ,
},
.suffix => {
state = .first;
result.suffix = name[last_end..i];
last_end = i + 1; // skip ,
},
else => {},
}
},
else => {}
}
}
result.first = name[last_end..];
return result;
}
};
pub const SingleField = struct {
value: []const u8,
};
inline fn is_single_field_type(field_type: FieldTypeTT) void {
return switch (field_type) {
.name_list, .literal_list, .key_list => false,
else => true,
};
}
test "parse name simple" {
var res = try ListField.parse_name("First von Last");
try expect(std.mem.eql(u8, res.first.?, "First"));
try expect(std.mem.eql(u8, res.prefix.?, "von"));
try expect(std.mem.eql(u8, res.last.?, "Last"));
try expect(res.suffix == null);
res = try ListField.parse_name("First Last");
try expect(std.mem.eql(u8, res.first.?, "First"));
try expect(res.prefix == null);
try expect(std.mem.eql(u8, res.last.?, "Last"));
try expect(res.suffix == null);
// currently not stripping whitespace in the First Last case
res = try ListField.parse_name("First Last ");
try expect(std.mem.eql(u8, res.first.?, "First "));
try expect(res.prefix == null);
try expect(std.mem.eql(u8, res.last.?, "Last "));
try expect(res.suffix == null);
res = try ListField.parse_name("Last-Last");
try expect(res.first == null);
try expect(res.prefix == null);
try expect(std.mem.eql(u8, res.last.?, "Last-Last"));
try expect(res.suffix == null);
res = try ListField.parse_name("First J. Other von da of Last Last");
try expect(std.mem.eql(u8, res.first.?, "First J. Other"));
try expect(std.mem.eql(u8, res.prefix.?, "von da of"));
try expect(std.mem.eql(u8, res.last.?, "Last Last"));
try expect(res.suffix == null);
// only skipping initial whitespace for now
// TODO?
res = try ListField.parse_name(" First von Last");
try expect(std.mem.eql(u8, res.first.?, "First"));
try expect(std.mem.eql(u8, res.prefix.?, "von"));
try expect(std.mem.eql(u8, res.last.?, "Last"));
try expect(res.suffix == null);
}
test "parse name commas" {
var res = try ListField.parse_name("von Last, First");
try expect(std.mem.eql(u8, res.first.?, "First"));
try expect(std.mem.eql(u8, res.prefix.?, "von"));
try expect(std.mem.eql(u8, res.last.?, "Last"));
try expect(res.suffix == null);
res = try ListField.parse_name("von de of Last Last, First Other");
try expect(std.mem.eql(u8, res.first.?, "First Other"));
try expect(std.mem.eql(u8, res.prefix.?, "von de of"));
try expect(std.mem.eql(u8, res.last.?, "Last Last"));
try expect(res.suffix == null);
// 2 commas
res = try ListField.parse_name("von Last, Jr., First");
try expect(std.mem.eql(u8, res.first.?, "First"));
try expect(std.mem.eql(u8, res.prefix.?, "von"));
try expect(std.mem.eql(u8, res.last.?, "Last"));
try expect(std.mem.eql(u8, res.suffix.?, "Jr."));
res = try ListField.parse_name(" von de of Last Last, Jr. Sr., First Other");
try expect(std.mem.eql(u8, res.first.?, "First Other"));
try expect(std.mem.eql(u8, res.prefix.?, "von de of"));
try expect(std.mem.eql(u8, res.last.?, "Last Last"));
try expect(std.mem.eql(u8, res.suffix.?, "Jr. Sr."));
}
pub const Entry = struct {
_type: EntryType,
// label: []const u8,
fields: FieldMap,
/// FieldMap should be initialized with Bibliography.field_arena.allocator
/// so we don't have to deinit
pub fn init(allocator: *std.mem.Allocator, _type: EntryType) Entry {
return Entry{
._type = _type,
.fields = FieldMap.init(allocator),
};
}
pub fn deinit(self: *Entry) void {
self.fields.deinit();
}
};
/// not handling @STRING, @PREAMBLE since they're not mentioned in the
/// biblatex manual (only on the bibtex.org/format)
/// handling @COMMENT
pub const EntryType = enum {
// comment not actually an entry type -> content is ignored
comment,
article,
book,
mvbook,
inbook,
bookinbook,
suppbook,
booklet,
collection,
mvcollection,
incollection,
suppcollection,
dataset,
manual,
misc,
online,
patent,
periodical,
suppperiodical,
proceedings,
mvproceedings,
inproceedings,
reference,
mvreference,
inreference,
report,
set,
software,
thesis,
unpublished,
xdata,
// ?custom[a-f]
// aliases
conference, // -> inproceedings
electronic, // -> online
mastersthesis, // special case of thesis, as type tag
phdthesis, // special case of thesis, as type tag
techreport, // -> report, as type tag
www, // -> online
// non-standard types -> treated as misc
artwork,
audio,
bibnote,
commentary,
image,
jurisdiction,
legislation,
legal,
letter,
movie,
music,
performance,
review,
standard,
video,
};
pub const Field = struct {
// currently not storing str for custom FieldName here, use the key from FieldMap
name: FieldName,
data: FieldType,
};
pub const FieldName = enum {
// NOTE: IMPORTANT don't change the order of these since it requires to also change
// the switch in get_field_type below
// literal_field START
custom, // arbitrary name to e.g. save additional info
abstract,
addendum,
annotation,
booksubtitle,
booktitle,
booktitleaddon,
chapter,
edition, // can be integer or literal
eid,
entrysubtype,
eprintclass,
eprinttype,
eventtitle,
eventtitleaddon,
howpublished,
indextitle,
isan,
isbn,
ismn,
isrn,
issn,
issue,
issuetitle,
issuesubtitle,
issuetitleaddon,
iswc,
journaltitle,
journalsubtitle,
journaltitleaddon,
label,
library,
mainsubtitle,
maintitle,
maintitleaddon,
month,
nameaddon,
note,
number,
origtitle,
pagetotal,
part,
reprinttitle,
series,
shorthand,
shorthandintro,
shortjournal,
shortseries,
shorttitle,
subtitle,
title,
titleaddon,
venue,
version,
year,
usera,
userb,
userc,
userd,
usere,
userf,
verba,
verbb,
verbc,
annote, // alias for annotation
archiveprefix, // alias -> eprinttype
journal, // alias -> journaltitle
key, // aliast -> sortkey
primaryclass, // alias -> eprintclass
// literal_field END
//
// name_list START
afterword,
annotator,
author,
bookauthor,
commentator,
editor,
editora,
editorb,
editorc,
foreword,
holder,
introduction,
shortauthor,
shorteditor,
translator,
namea,
nameb,
namec,
// name_list END
//
// key_field START
authortype,
bookpagination,
editortype,
editoratype,
editorbtype,
editorctype,
pagination,
@"type",
nameatype,
namebtype,
namectype,
// key_field END
//
// date_field START
date,
eventdate,
origdate,
urldate,
// date_field END
//
// verbatim_field START
doi,
eprint,
file,
pdf, // alias -> file
// verbatim_field END
//
// literal_list START
institution,
location,
organization,
origlocation,
origpublisher,
publisher,
pubstate,
lista,
listb,
listc,
listd,
liste,
listf,
address, // alias for location
school, // alias -> institution
// literal_list END
//
// key_list START
language,
origlanguage,
// key_list END
//
// range_field START
pages,
// range_field END
//
// uri_field START
url,
// uri_field END
//
// integer_field START
volume,
volumes,
// integer_field END
//
// special fields START
ids,
crossref,
fakeset,
gender,
entryset,
execute,
hyphenation,
indexsorttitle,
keywords,
langid,
langidopts,
options,
presort,
related,
relatedoptions,
relatedtype,
sortshorthand,
sortkey,
sortname,
sorttitle,
sortyear,
xref,
// special fields END
pub fn get_field_type(self: FieldName) FieldTypeTT {
// ... is not allowed with enums, so cast it to it's underlying int tag type
return switch (@enumToInt(self)) {
@enumToInt(FieldName.custom) ... @enumToInt(FieldName.primaryclass) => .literal_field,
@enumToInt(FieldName.afterword) ... @enumToInt(FieldName.namec) => .name_list,
@enumToInt(FieldName.authortype) ... @enumToInt(FieldName.namectype) => .key_field,
@enumToInt(FieldName.date) ... @enumToInt(FieldName.urldate) => .date_field,
@enumToInt(FieldName.doi) ... @enumToInt(FieldName.pdf) => .verbatim_field,
@enumToInt(FieldName.institution) ... @enumToInt(FieldName.school) => .literal_list,
@enumToInt(FieldName.language), @enumToInt(FieldName.origlanguage) => .key_list,
@enumToInt(FieldName.pages) => .range_field,
@enumToInt(FieldName.url) => .uri_field,
@enumToInt(FieldName.volume), @enumToInt(FieldName.volumes) => .integer_field,
@enumToInt(FieldName.ids) ... @enumToInt(FieldName.xref) => .special_field,
else => unreachable,
};
}
};
| 32.927035 | 122 | 0.534816 |
414b4e5fe0ea0bab74b5f9821c76a96aab31b6c3 | 40,007 | zig | Zig | libs/zgpu/src/zgpu.zig | kokizzu/zig-gamedev | 794ede6a00e97f8b7c69d99a88ba1c9cca1db65b | [
"MIT"
] | 1 | 2021-12-31T05:11:43.000Z | 2021-12-31T05:11:43.000Z | libs/zgpu/src/zgpu.zig | kokizzu/zig-gamedev | 794ede6a00e97f8b7c69d99a88ba1c9cca1db65b | [
"MIT"
] | null | null | null | libs/zgpu/src/zgpu.zig | kokizzu/zig-gamedev | 794ede6a00e97f8b7c69d99a88ba1c9cca1db65b | [
"MIT"
] | null | null | null | const std = @import("std");
const assert = std.debug.assert;
const glfw = @import("glfw");
const c = @cImport({
@cInclude("dawn/dawn_proc.h");
@cInclude("dawn_native_mach.h");
});
const objc = @cImport({
@cInclude("objc/message.h");
});
pub const cimgui = @cImport({
@cDefine("CIMGUI_DEFINE_ENUMS_AND_STRUCTS", "");
@cDefine("CIMGUI_NO_EXPORT", "");
@cInclude("imgui/cimgui.h");
});
pub const gpu = @import("mach-gpu/main.zig");
const wgsl = @import("common_wgsl.zig");
pub const SwapChainState = enum {
normal,
swap_chain_resized,
};
pub const GraphicsContext = struct {
native_instance: gpu.NativeInstance,
adapter_type: gpu.Adapter.Type,
backend_type: gpu.Adapter.BackendType,
device: gpu.Device,
queue: gpu.Queue,
window: glfw.Window,
window_width: u32,
window_height: u32,
window_surface: gpu.Surface,
swapchain: gpu.SwapChain,
swapchain_descriptor: gpu.SwapChain.Descriptor,
buffer_pool: BufferPool,
texture_pool: TexturePool,
texture_view_pool: TextureViewPool,
sampler_pool: SamplerPool,
render_pipeline_pool: RenderPipelinePool,
compute_pipeline_pool: ComputePipelinePool,
bind_group_pool: BindGroupPool,
bind_group_layout_pool: BindGroupLayoutPool,
mipgen: struct {
pipeline: ComputePipelineHandle = .{},
scratch_texture: TextureHandle = .{},
scratch_texture_views: [4]TextureViewHandle = [_]TextureViewHandle{.{}} ** 4,
bind_group_layout: BindGroupLayoutHandle = .{},
} = .{},
stats: FrameStats = .{},
pub const swapchain_format = gpu.Texture.Format.bgra8_unorm;
// TODO: Adjust pool sizes.
const buffer_pool_size = 256;
const texture_pool_size = 256;
const texture_view_pool_size = 256;
const sampler_pool_size = 16;
const render_pipeline_pool_size = 128;
const compute_pipeline_pool_size = 128;
const bind_group_pool_size = 32;
const bind_group_layout_pool_size = 32;
pub fn init(allocator: std.mem.Allocator, window: glfw.Window) !GraphicsContext {
c.dawnProcSetProcs(c.machDawnNativeGetProcs());
const instance = c.machDawnNativeInstance_init();
c.machDawnNativeInstance_discoverDefaultAdapters(instance);
var native_instance = gpu.NativeInstance.wrap(c.machDawnNativeInstance_get(instance).?);
const gpu_interface = native_instance.interface();
const backend_adapter = switch (gpu_interface.waitForAdapter(&.{
.power_preference = .high_performance,
})) {
.adapter => |v| v,
.err => |err| {
std.debug.print("[zgpu] Failed to get adapter: error={} {s}.\n", .{ err.code, err.message });
return error.NoGraphicsAdapter;
},
};
const props = backend_adapter.properties;
std.debug.print("[zgpu] High-performance device has been selected:\n", .{});
std.debug.print("[zgpu] Name: {s}\n", .{props.name});
std.debug.print("[zgpu] Driver: {s}\n", .{props.driver_description});
std.debug.print("[zgpu] Adapter type: {s}\n", .{gpu.Adapter.typeName(props.adapter_type)});
std.debug.print("[zgpu] Backend type: {s}\n", .{gpu.Adapter.backendTypeName(props.backend_type)});
const device = switch (backend_adapter.waitForDevice(&.{})) {
.device => |v| v,
.err => |err| {
std.debug.print("[zgpu] Failed to get device: error={} {s}\n", .{ err.code, err.message });
return error.NoGraphicsDevice;
},
};
device.setUncapturedErrorCallback(&printUnhandledErrorCallback);
const window_surface = createSurfaceForWindow(
&native_instance,
window,
comptime detectGLFWOptions(),
);
const window_size = window.getSize() catch unreachable;
const framebuffer_size = window.getFramebufferSize() catch unreachable;
const swapchain_descriptor = gpu.SwapChain.Descriptor{
.label = "main window swap chain",
.usage = .{ .render_attachment = true },
.format = swapchain_format,
.width = framebuffer_size.width,
.height = framebuffer_size.height,
.present_mode = .fifo,
.implementation = 0,
};
const swapchain = device.nativeCreateSwapChain(
window_surface,
&swapchain_descriptor,
);
return GraphicsContext{
.native_instance = native_instance,
.adapter_type = props.adapter_type,
.backend_type = props.backend_type,
.device = device,
.queue = device.getQueue(),
.window = window,
.window_width = window_size.width,
.window_height = window_size.height,
.window_surface = window_surface,
.swapchain = swapchain,
.swapchain_descriptor = swapchain_descriptor,
.buffer_pool = BufferPool.init(allocator, buffer_pool_size),
.texture_pool = TexturePool.init(allocator, texture_pool_size),
.texture_view_pool = TextureViewPool.init(allocator, texture_view_pool_size),
.sampler_pool = SamplerPool.init(allocator, sampler_pool_size),
.render_pipeline_pool = RenderPipelinePool.init(allocator, render_pipeline_pool_size),
.compute_pipeline_pool = ComputePipelinePool.init(allocator, compute_pipeline_pool_size),
.bind_group_pool = BindGroupPool.init(allocator, bind_group_pool_size),
.bind_group_layout_pool = BindGroupLayoutPool.init(allocator, bind_group_layout_pool_size),
};
}
pub fn deinit(gctx: *GraphicsContext, allocator: std.mem.Allocator) void {
// TODO: How to release `native_instance`?
gctx.bind_group_pool.deinit(allocator);
gctx.bind_group_layout_pool.deinit(allocator);
gctx.buffer_pool.deinit(allocator);
gctx.texture_view_pool.deinit(allocator);
gctx.texture_pool.deinit(allocator);
gctx.sampler_pool.deinit(allocator);
gctx.render_pipeline_pool.deinit(allocator);
gctx.compute_pipeline_pool.deinit(allocator);
gctx.window_surface.release();
gctx.swapchain.release();
gctx.queue.release();
gctx.device.release();
gctx.* = undefined;
}
pub fn present(gctx: *GraphicsContext) SwapChainState {
gctx.swapchain.present();
gctx.stats.update();
const win_size = gctx.window.getSize() catch unreachable;
const fb_size = gctx.window.getFramebufferSize() catch unreachable;
if (gctx.swapchain_descriptor.width != fb_size.width or
gctx.swapchain_descriptor.height != fb_size.height)
{
gctx.swapchain_descriptor.width = fb_size.width;
gctx.swapchain_descriptor.height = fb_size.height;
gctx.swapchain.release();
gctx.swapchain = gctx.device.nativeCreateSwapChain(
gctx.window_surface,
&gctx.swapchain_descriptor,
);
gctx.window_width = win_size.width;
gctx.window_height = win_size.height;
std.debug.print(
"[zgpu] Window has been resized to: {d}x{d} pixels ({d}x{d} units).\n",
.{
gctx.swapchain_descriptor.width,
gctx.swapchain_descriptor.height,
gctx.window_width,
gctx.window_height,
},
);
return .swap_chain_resized;
}
return .normal;
}
pub fn createBuffer(gctx: *GraphicsContext, descriptor: gpu.Buffer.Descriptor) BufferHandle {
return gctx.buffer_pool.addResource(gctx.*, .{
.gpuobj = gctx.device.createBuffer(&descriptor),
.size = descriptor.size,
.usage = descriptor.usage,
});
}
pub fn createTexture(gctx: *GraphicsContext, descriptor: gpu.Texture.Descriptor) TextureHandle {
return gctx.texture_pool.addResource(gctx.*, .{
.gpuobj = gctx.device.createTexture(&descriptor),
.usage = descriptor.usage,
.dimension = descriptor.dimension,
.size = descriptor.size,
.format = descriptor.format,
.mip_level_count = descriptor.mip_level_count,
.sample_count = descriptor.sample_count,
});
}
pub fn createTextureView(
gctx: *GraphicsContext,
texture_handle: TextureHandle,
descriptor: gpu.TextureView.Descriptor,
) TextureViewHandle {
const texture = gctx.lookupResource(texture_handle).?;
return gctx.texture_view_pool.addResource(gctx.*, .{
.gpuobj = texture.createView(&descriptor),
.format = descriptor.format,
.dimension = descriptor.dimension,
.base_mip_level = descriptor.base_mip_level,
.base_array_layer = descriptor.base_array_layer,
.array_layer_count = descriptor.array_layer_count,
.aspect = descriptor.aspect,
.parent_texture_handle = texture_handle,
});
}
pub fn createSampler(gctx: *GraphicsContext, descriptor: gpu.Sampler.Descriptor) SamplerHandle {
return gctx.sampler_pool.addResource(gctx.*, .{
.gpuobj = gctx.device.createSampler(&descriptor),
.address_mode_u = descriptor.address_mode_u,
.address_mode_v = descriptor.address_mode_v,
.address_mode_w = descriptor.address_mode_w,
.mag_filter = descriptor.mag_filter,
.min_filter = descriptor.min_filter,
.mipmap_filter = descriptor.mipmap_filter,
.lod_min_clamp = descriptor.lod_min_clamp,
.lod_max_clamp = descriptor.lod_max_clamp,
.compare = descriptor.compare,
.max_anisotropy = descriptor.max_anisotropy,
});
}
pub fn createRenderPipeline(
gctx: *GraphicsContext,
descriptor: gpu.RenderPipeline.Descriptor,
) RenderPipelineHandle {
return gctx.render_pipeline_pool.addResource(gctx.*, .{
.gpuobj = gctx.device.createRenderPipeline(&descriptor),
});
}
pub fn createComputePipeline(
gctx: *GraphicsContext,
descriptor: gpu.ComputePipeline.Descriptor,
) ComputePipelineHandle {
return gctx.compute_pipeline_pool.addResource(gctx.*, .{
.gpuobj = gctx.device.createComputePipeline(&descriptor),
});
}
pub fn createBindGroup(
gctx: *GraphicsContext,
layout: BindGroupLayoutHandle,
entries: []const BindGroupEntryInfo,
) BindGroupHandle {
assert(entries.len > 0 and entries.len < max_num_bindings_per_group);
var bind_group_info = BindGroupInfo{ .num_active_entries = @intCast(u32, entries.len) };
var gpu_bind_group_entries: [max_num_bindings_per_group]gpu.BindGroup.Entry = undefined;
for (entries) |entry, i| {
bind_group_info.entries[i] = entry;
if (entries[i].buffer_handle) |handle| {
gpu_bind_group_entries[i] = .{
.binding = entries[i].binding,
.buffer = gctx.lookupResource(handle).?,
.offset = entries[i].offset,
.size = entries[i].size,
.sampler = null,
.texture_view = null,
};
} else if (entries[i].sampler_handle) |handle| {
gpu_bind_group_entries[i] = .{
.binding = entries[i].binding,
.buffer = null,
.offset = 0,
.size = 0,
.sampler = gctx.lookupResource(handle).?,
.texture_view = null,
};
} else if (entries[i].texture_view_handle) |handle| {
gpu_bind_group_entries[i] = .{
.binding = entries[i].binding,
.buffer = null,
.offset = 0,
.size = 0,
.sampler = null,
.texture_view = gctx.lookupResource(handle).?,
};
} else unreachable;
}
bind_group_info.gpuobj = gctx.device.createBindGroup(&.{
.layout = gctx.lookupResource(layout).?,
.entries = gpu_bind_group_entries[0..entries.len],
});
return gctx.bind_group_pool.addResource(gctx.*, bind_group_info);
}
pub fn createBindGroupLayout(
gctx: *GraphicsContext,
descriptor: gpu.BindGroupLayout.Descriptor,
) BindGroupLayoutHandle {
assert(descriptor.entries.len > 0 and descriptor.entries.len < max_num_bindings_per_group);
var bind_group_layout_info = BindGroupLayoutInfo{
.gpuobj = gctx.device.createBindGroupLayout(&descriptor),
.num_active_entries = @intCast(u32, descriptor.entries.len),
};
for (descriptor.entries) |entry, i| {
bind_group_layout_info.entries[i] = entry;
bind_group_layout_info.entries[i].reserved = null;
bind_group_layout_info.entries[i].buffer.reserved = null;
bind_group_layout_info.entries[i].sampler.reserved = null;
bind_group_layout_info.entries[i].texture.reserved = null;
bind_group_layout_info.entries[i].storage_texture.reserved = null;
}
return gctx.bind_group_layout_pool.addResource(gctx.*, bind_group_layout_info);
}
pub fn createBindGroupLayoutAuto(
gctx: *GraphicsContext,
pipeline: anytype,
group_index: u32,
) BindGroupLayoutHandle {
const bgl = gctx.lookupResource(pipeline).?.getBindGroupLayout(group_index);
return gctx.bind_group_layout_pool.addResource(gctx.*, BindGroupLayoutInfo{ .gpuobj = bgl });
}
pub fn lookupResource(gctx: GraphicsContext, handle: anytype) ?handleToGpuResourceType(@TypeOf(handle)) {
if (gctx.isResourceValid(handle)) {
const T = @TypeOf(handle);
return switch (T) {
BufferHandle => gctx.buffer_pool.resources[handle.index].gpuobj.?,
TextureHandle => gctx.texture_pool.resources[handle.index].gpuobj.?,
TextureViewHandle => gctx.texture_view_pool.resources[handle.index].gpuobj.?,
SamplerHandle => gctx.sampler_pool.resources[handle.index].gpuobj.?,
RenderPipelineHandle => gctx.render_pipeline_pool.resources[handle.index].gpuobj.?,
ComputePipelineHandle => gctx.compute_pipeline_pool.resources[handle.index].gpuobj.?,
BindGroupHandle => gctx.bind_group_pool.resources[handle.index].gpuobj.?,
BindGroupLayoutHandle => gctx.bind_group_layout_pool.resources[handle.index].gpuobj.?,
else => @compileError(
"[zgpu] GraphicsContext.lookupResource() not implemented for " ++ @typeName(T),
),
};
}
return null;
}
pub fn lookupResourceInfo(gctx: GraphicsContext, handle: anytype) ?handleToResourceInfoType(@TypeOf(handle)) {
if (gctx.isResourceValid(handle)) {
const T = @TypeOf(handle);
return switch (T) {
BufferHandle => gctx.buffer_pool.resources[handle.index],
TextureHandle => gctx.texture_pool.resources[handle.index],
TextureViewHandle => gctx.texture_view_pool.resources[handle.index],
SamplerHandle => gctx.sampler_pool.resources[handle.index],
RenderPipelineHandle => gctx.render_pipeline_pool.resources[handle.index],
ComputePipelineHandle => gctx.compute_pipeline_pool.resources[handle.index],
BindGroupHandle => gctx.bind_group_pool.resources[handle.index],
BindGroupLayoutHandle => gctx.bind_group_layout_pool.resources[handle.index],
else => @compileError(
"[zgpu] GraphicsContext.lookupResourceInfo() not implemented for " ++ @typeName(T),
),
};
}
return null;
}
pub fn destroyResource(gctx: GraphicsContext, handle: anytype) void {
const T = @TypeOf(handle);
switch (T) {
BufferHandle => gctx.buffer_pool.destroyResource(handle),
TextureHandle => gctx.texture_pool.destroyResource(handle),
TextureViewHandle => gctx.texture_view_pool.destroyResource(handle),
SamplerHandle => gctx.sampler_pool.destroyResource(handle),
RenderPipelineHandle => gctx.render_pipeline_pool.destroyResource(handle),
ComputePipelineHandle => gctx.compute_pipeline_pool.destroyResource(handle),
BindGroupHandle => gctx.bind_group_pool.destroyResource(handle),
BindGroupLayoutHandle => gctx.bind_group_layout_pool.destroyResource(handle),
else => @compileError("[zgpu] GraphicsContext.destroyResource() not implemented for " ++ @typeName(T)),
}
}
pub fn isResourceValid(gctx: GraphicsContext, handle: anytype) bool {
const T = @TypeOf(handle);
switch (T) {
BufferHandle => return gctx.buffer_pool.isHandleValid(handle),
TextureHandle => return gctx.texture_pool.isHandleValid(handle),
TextureViewHandle => {
if (gctx.texture_view_pool.isHandleValid(handle)) {
const texture = gctx.texture_view_pool.resources[handle.index].parent_texture_handle;
return gctx.isResourceValid(texture);
}
return false;
},
SamplerHandle => return gctx.sampler_pool.isHandleValid(handle),
RenderPipelineHandle => return gctx.render_pipeline_pool.isHandleValid(handle),
ComputePipelineHandle => return gctx.compute_pipeline_pool.isHandleValid(handle),
BindGroupHandle => {
if (gctx.bind_group_pool.isHandleValid(handle)) {
const num_entries = gctx.bind_group_pool.resources[handle.index].num_active_entries;
const entries = &gctx.bind_group_pool.resources[handle.index].entries;
var i: u32 = 0;
while (i < num_entries) : (i += 1) {
if (entries[i].buffer_handle) |buffer| {
if (!gctx.isResourceValid(buffer))
return false;
} else if (entries[i].sampler_handle) |sampler| {
if (!gctx.isResourceValid(sampler))
return false;
} else if (entries[i].texture_view_handle) |texture_view| {
if (!gctx.isResourceValid(texture_view))
return false;
} else unreachable;
}
return true;
}
return false;
},
BindGroupLayoutHandle => return gctx.bind_group_layout_pool.isHandleValid(handle),
else => @compileError("[zgpu] GraphicsContext.isResourceValid() not implemented for " ++ @typeName(T)),
}
}
pub fn generateMipmaps(gctx: *GraphicsContext, texture: TextureHandle) void {
const texture_info = gctx.lookupResourceInfo(texture) orelse return;
if (texture_info.dimension != .dimension_2d) {
// TODO: Print message.
return;
}
if (!gctx.isResourceValid(gctx.mipgen.pipeline)) {
const cs_module = gctx.device.createShaderModule(&.{
.label = "zgpu_cs_generate_mipmaps",
.code = .{ .wgsl = wgsl.cs_generate_mipmaps },
});
defer cs_module.release();
gctx.mipgen.pipeline = gctx.createComputePipeline(.{
.compute = .{
.label = "zgpu_cs_generate_mipmaps",
.module = cs_module,
.entry_point = "main",
},
});
gctx.mipgen.bind_group_layout = gctx.createBindGroupLayoutAuto(gctx.mipgen.pipeline, 0);
gctx.mipgen.scratch_texture = gctx.createTexture(.{
.usage = .{ .copy_src = true, .storage_binding = true },
.dimension = .dimension_2d,
.size = .{ .width = 1024, .height = 1024, .depth_or_array_layers = 1 },
.format = .rgba32_float,
.mip_level_count = 4,
.sample_count = 1,
});
for (gctx.mipgen.scratch_texture_views) |*view, i| {
view.* = gctx.createTextureView(gctx.mipgen.scratch_texture, .{
.format = .rgba32_float,
.dimension = .dimension_2d,
.base_mip_level = @intCast(u32, i),
.mip_level_count = 1,
.base_array_layer = 0,
.array_layer_count = 1,
});
}
}
const uniform_buffer = gctx.createBuffer(.{
.usage = .{ .copy_dst = true, .uniform = true },
.size = 8,
});
defer gctx.destroyResource(uniform_buffer);
const texture_view = gctx.createTextureView(texture, .{
.format = texture_info.format,
.dimension = .dimension_2d,
.base_mip_level = 0,
.mip_level_count = texture_info.mip_level_count,
.base_array_layer = 0,
.array_layer_count = texture_info.size.depth_or_array_layers,
});
defer gctx.destroyResource(texture_view);
const draw_bind_group = gctx.createBindGroup(gctx.mipgen.bind_group_layout, &[_]BindGroupEntryInfo{
.{ .binding = 0, .buffer_handle = uniform_buffer, .offset = 0, .size = 8 },
.{ .binding = 1, .texture_view_handle = texture_view },
.{ .binding = 2, .texture_view_handle = gctx.mipgen.scratch_texture_views[0] },
.{ .binding = 3, .texture_view_handle = gctx.mipgen.scratch_texture_views[1] },
.{ .binding = 4, .texture_view_handle = gctx.mipgen.scratch_texture_views[2] },
.{ .binding = 5, .texture_view_handle = gctx.mipgen.scratch_texture_views[3] },
});
defer gctx.destroyResource(draw_bind_group);
}
};
pub const BufferHandle = struct { index: u16 align(4) = 0, generation: u16 = 0 };
pub const TextureHandle = struct { index: u16 align(4) = 0, generation: u16 = 0 };
pub const TextureViewHandle = struct { index: u16 align(4) = 0, generation: u16 = 0 };
pub const SamplerHandle = struct { index: u16 align(4) = 0, generation: u16 = 0 };
pub const RenderPipelineHandle = struct { index: u16 align(4) = 0, generation: u16 = 0 };
pub const ComputePipelineHandle = struct { index: u16 align(4) = 0, generation: u16 = 0 };
pub const BindGroupHandle = struct { index: u16 align(4) = 0, generation: u16 = 0 };
pub const BindGroupLayoutHandle = struct { index: u16 align(4) = 0, generation: u16 = 0 };
pub const BufferInfo = struct {
gpuobj: ?gpu.Buffer = null,
size: usize = 0,
usage: gpu.BufferUsage = .{},
};
pub const TextureInfo = struct {
gpuobj: ?gpu.Texture = null,
usage: gpu.Texture.Usage = .{},
dimension: gpu.Texture.Dimension = .dimension_1d,
size: gpu.Extent3D = .{ .width = 0 },
format: gpu.Texture.Format = .none,
mip_level_count: u32 = 0,
sample_count: u32 = 0,
};
pub const TextureViewInfo = struct {
gpuobj: ?gpu.TextureView = null,
format: gpu.Texture.Format = .none,
dimension: gpu.TextureView.Dimension = .dimension_none,
base_mip_level: u32 = 0,
base_array_layer: u32 = 0,
array_layer_count: u32 = 0,
aspect: gpu.Texture.Aspect = .all,
parent_texture_handle: TextureHandle = .{},
};
pub const SamplerInfo = struct {
gpuobj: ?gpu.Sampler = null,
address_mode_u: gpu.AddressMode = .repeat,
address_mode_v: gpu.AddressMode = .repeat,
address_mode_w: gpu.AddressMode = .repeat,
mag_filter: gpu.FilterMode = .nearest,
min_filter: gpu.FilterMode = .nearest,
mipmap_filter: gpu.FilterMode = .nearest,
lod_min_clamp: f32 = 0.0,
lod_max_clamp: f32 = 0.0,
compare: gpu.CompareFunction = .none,
max_anisotropy: u16 = 0,
};
const RenderPipelineInfo = struct {
gpuobj: ?gpu.RenderPipeline = null,
};
const ComputePipelineInfo = struct {
gpuobj: ?gpu.ComputePipeline = null,
};
pub const BindGroupEntryInfo = struct {
binding: u32 = 0,
buffer_handle: ?BufferHandle = null,
offset: u64 = 0,
size: u64 = 0,
sampler_handle: ?SamplerHandle = null,
texture_view_handle: ?TextureViewHandle = null,
};
pub const max_num_bindings_per_group = 8;
pub const BindGroupInfo = struct {
gpuobj: ?gpu.BindGroup = null,
num_active_entries: u32 = 0,
entries: [max_num_bindings_per_group]BindGroupEntryInfo =
[_]BindGroupEntryInfo{.{}} ** max_num_bindings_per_group,
};
pub const BindGroupLayoutInfo = struct {
gpuobj: ?gpu.BindGroupLayout = null,
num_active_entries: u32 = 0,
entries: [max_num_bindings_per_group]gpu.BindGroupLayout.Entry =
[_]gpu.BindGroupLayout.Entry{.{ .binding = 0, .visibility = .{} }} ** max_num_bindings_per_group,
};
const BufferPool = ResourcePool(BufferInfo, BufferHandle);
const TexturePool = ResourcePool(TextureInfo, TextureHandle);
const TextureViewPool = ResourcePool(TextureViewInfo, TextureViewHandle);
const SamplerPool = ResourcePool(SamplerInfo, SamplerHandle);
const RenderPipelinePool = ResourcePool(RenderPipelineInfo, RenderPipelineHandle);
const ComputePipelinePool = ResourcePool(ComputePipelineInfo, ComputePipelineHandle);
const BindGroupPool = ResourcePool(BindGroupInfo, BindGroupHandle);
const BindGroupLayoutPool = ResourcePool(BindGroupLayoutInfo, BindGroupLayoutHandle);
fn ResourcePool(comptime ResourceInfo: type, comptime ResourceHandle: type) type {
return struct {
const Self = @This();
resources: []ResourceInfo,
generations: []u16,
start_slot_index: u32 = 0,
fn init(allocator: std.mem.Allocator, capacity: u32) Self {
var resources = allocator.alloc(ResourceInfo, capacity + 1) catch unreachable;
for (resources) |*resource| resource.* = .{};
var generations = allocator.alloc(u16, capacity + 1) catch unreachable;
for (generations) |*gen| gen.* = 0;
return .{
.resources = resources,
.generations = generations,
};
}
fn deinit(pool: *Self, allocator: std.mem.Allocator) void {
for (pool.resources) |resource| {
if (resource.gpuobj) |gpuobj| {
if (@hasDecl(@TypeOf(gpuobj), "destroy")) {
gpuobj.destroy();
}
gpuobj.release();
}
}
allocator.free(pool.resources);
allocator.free(pool.generations);
pool.* = undefined;
}
fn addResource(pool: *Self, gctx: GraphicsContext, resource: ResourceInfo) ResourceHandle {
assert(resource.gpuobj != null);
var index: u32 = 0;
var found_slot_index: u32 = 0;
while (index < pool.resources.len) : (index += 1) {
const slot_index = (pool.start_slot_index + index) % @intCast(u32, pool.resources.len);
if (slot_index == 0) // Skip index 0 because it is reserved for `invalid handle`.
continue;
if (pool.resources[slot_index].gpuobj == null) { // If `gpuobj` is null slot is free.
found_slot_index = slot_index;
break;
} else {
// If `gpuobj` is not null slot can still be free because dependent resources could
// have become invalid. For example, texture view becomes invalid when parent texture
// is destroyed.
const handle = ResourceHandle{ // Construct a *valid* handle for the slot that we want to check.
.index = @intCast(u16, slot_index),
.generation = pool.generations[slot_index],
};
// Check the handle (will always be valid) and its potential dependencies (may be invalid).
if (!gctx.isResourceValid(handle)) {
// Destroy old resource (it is invalid because some of its dependencies are invalid).
pool.destroyResource(handle);
found_slot_index = slot_index;
break;
}
}
}
// TODO: For now we just assert if pool is full - make it more roboust.
assert(found_slot_index > 0 and found_slot_index < pool.resources.len);
pool.start_slot_index = found_slot_index + 1;
pool.resources[found_slot_index] = resource;
return .{
.index = @intCast(u16, found_slot_index),
.generation = generation: {
pool.generations[found_slot_index] += 1;
break :generation pool.generations[found_slot_index];
},
};
}
fn destroyResource(pool: Self, handle: ResourceHandle) void {
if (!pool.isHandleValid(handle))
return;
var resource_info = &pool.resources[handle.index];
const gpuobj = resource_info.gpuobj.?;
if (@hasDecl(@TypeOf(gpuobj), "destroy")) {
gpuobj.destroy();
}
gpuobj.release();
resource_info.* = .{};
}
fn isHandleValid(pool: Self, handle: ResourceHandle) bool {
return handle.index > 0 and
handle.index < pool.resources.len and
handle.generation > 0 and
handle.generation == pool.generations[handle.index] and
pool.resources[handle.index].gpuobj != null;
}
};
}
pub fn checkContent(comptime content_dir: []const u8) !void {
const local = struct {
fn impl() !void {
// Change directory to where an executable is located.
{
var exe_path_buffer: [1024]u8 = undefined;
const exe_path = std.fs.selfExeDirPath(exe_path_buffer[0..]) catch "./";
std.os.chdir(exe_path) catch {};
}
// Make sure font file is a valid data file and not just a Git LFS pointer.
{
const file = try std.fs.cwd().openFile(content_dir ++ "Roboto-Medium.ttf", .{});
defer file.close();
const size = @intCast(usize, try file.getEndPos());
if (size <= 1024) {
return error.InvalidDataFiles;
}
}
}
};
local.impl() catch |err| {
std.debug.print(
\\
\\DATA ERROR
\\
\\Invalid data files or missing content folder.
\\Please install Git LFS (Large File Support) and run (in the repo):
\\
\\git lfs install
\\git pull
\\
\\For more info please see: https://git-lfs.github.com/
\\
\\
,
.{},
);
return err;
};
}
const FrameStats = struct {
time: f64 = 0.0,
delta_time: f32 = 0.0,
fps: f32 = 0.0,
fps_counter: u32 = 0,
average_cpu_time: f32 = 0.0,
previous_time: f64 = 0.0,
fps_refresh_time: f64 = 0.0,
frame_number: u64 = 0,
fn update(stats: *FrameStats) void {
stats.time = glfw.getTime();
stats.delta_time = @floatCast(f32, stats.time - stats.previous_time);
stats.previous_time = stats.time;
if ((stats.time - stats.fps_refresh_time) >= 1.0) {
const t = stats.time - stats.fps_refresh_time;
const fps = @intToFloat(f64, stats.fps_counter) / t;
const ms = (1.0 / fps) * 1000.0;
stats.fps = @floatCast(f32, fps);
stats.average_cpu_time = @floatCast(f32, ms);
stats.fps_refresh_time = stats.time;
stats.fps_counter = 0;
}
stats.fps_counter += 1;
stats.frame_number += 1;
}
};
pub const gui = struct {
pub fn init(window: glfw.Window, device: gpu.Device, font: [*:0]const u8, font_size: f32) void {
assert(cimgui.igGetCurrentContext() == null);
_ = cimgui.igCreateContext(null);
if (!ImGui_ImplGlfw_InitForOther(window.handle, true)) {
unreachable;
}
const io = cimgui.igGetIO().?;
if (cimgui.ImFontAtlas_AddFontFromFileTTF(io.*.Fonts, font, font_size, null, null) == null) {
unreachable;
}
if (!ImGui_ImplWGPU_Init(
device.ptr,
1, // Number of `frames in flight`. One is enough because Dawn creates staging buffers internally.
@enumToInt(GraphicsContext.swapchain_format),
)) {
unreachable;
}
}
pub fn deinit() void {
assert(cimgui.igGetCurrentContext() != null);
ImGui_ImplWGPU_Shutdown();
ImGui_ImplGlfw_Shutdown();
cimgui.igDestroyContext(null);
}
pub fn newFrame(win_width: u32, win_height: u32, fb_width: u32, fb_height: u32) void {
ImGui_ImplGlfw_NewFrame(win_width, win_height, fb_width, fb_height);
ImGui_ImplWGPU_NewFrame();
cimgui.igNewFrame();
}
pub fn draw(pass: gpu.RenderPassEncoder) void {
cimgui.igRender();
ImGui_ImplWGPU_RenderDrawData(cimgui.igGetDrawData(), pass.ptr);
}
extern fn ImGui_ImplGlfw_InitForOther(window: *anyopaque, install_callbacks: bool) bool;
extern fn ImGui_ImplGlfw_NewFrame(window_w: u32, window_h: u32, framebuffer_w: u32, framebuffer_h: u32) void;
extern fn ImGui_ImplGlfw_Shutdown() void;
extern fn ImGui_ImplWGPU_Init(device: *anyopaque, num_frames_in_flight: u32, rt_format: u32) bool;
extern fn ImGui_ImplWGPU_NewFrame() void;
extern fn ImGui_ImplWGPU_RenderDrawData(draw_data: *anyopaque, pass_encoder: *anyopaque) void;
extern fn ImGui_ImplWGPU_Shutdown() void;
};
fn detectGLFWOptions() glfw.BackendOptions {
const target = @import("builtin").target;
if (target.isDarwin()) return .{ .cocoa = true };
return switch (target.os.tag) {
.windows => .{ .win32 = true },
.linux => .{ .x11 = true },
else => .{},
};
}
fn createSurfaceForWindow(
native_instance: *const gpu.NativeInstance,
window: glfw.Window,
comptime glfw_options: glfw.BackendOptions,
) gpu.Surface {
const glfw_native = glfw.Native(glfw_options);
const descriptor = if (glfw_options.win32) gpu.Surface.Descriptor{
.windows_hwnd = .{
.label = "basic surface",
.hinstance = std.os.windows.kernel32.GetModuleHandleW(null).?,
.hwnd = glfw_native.getWin32Window(window),
},
} else if (glfw_options.x11) gpu.Surface.Descriptor{
.xlib = .{
.label = "basic surface",
.display = glfw_native.getX11Display(),
.window = glfw_native.getX11Window(window),
},
} else if (glfw_options.cocoa) blk: {
const ns_window = glfw_native.getCocoaWindow(window);
const ns_view = msgSend(ns_window, "contentView", .{}, *anyopaque); // [nsWindow contentView]
// Create a CAMetalLayer that covers the whole window that will be passed to CreateSurface.
msgSend(ns_view, "setWantsLayer:", .{true}, void); // [view setWantsLayer:YES]
const layer = msgSend(objc.objc_getClass("CAMetalLayer"), "layer", .{}, ?*anyopaque); // [CAMetalLayer layer]
if (layer == null) @panic("failed to create Metal layer");
msgSend(ns_view, "setLayer:", .{layer.?}, void); // [view setLayer:layer]
// Use retina if the window was created with retina support.
const scale_factor = msgSend(ns_window, "backingScaleFactor", .{}, f64); // [ns_window backingScaleFactor]
msgSend(layer.?, "setContentsScale:", .{scale_factor}, void); // [layer setContentsScale:scale_factor]
break :blk gpu.Surface.Descriptor{
.metal_layer = .{
.label = "basic surface",
.layer = layer.?,
},
};
} else if (glfw_options.wayland) {
// bugs.chromium.org/p/dawn/issues/detail?id=1246&q=surface&can=2
@panic("Dawn does not yet have Wayland support");
} else unreachable;
return native_instance.createSurface(&descriptor);
}
// Borrowed from https://github.com/hazeycode/zig-objcrt
fn msgSend(obj: anytype, sel_name: [:0]const u8, args: anytype, comptime ReturnType: type) ReturnType {
const args_meta = @typeInfo(@TypeOf(args)).Struct.fields;
const FnType = switch (args_meta.len) {
0 => fn (@TypeOf(obj), objc.SEL) callconv(.C) ReturnType,
1 => fn (@TypeOf(obj), objc.SEL, args_meta[0].field_type) callconv(.C) ReturnType,
2 => fn (@TypeOf(obj), objc.SEL, args_meta[0].field_type, args_meta[1].field_type) callconv(.C) ReturnType,
3 => fn (
@TypeOf(obj),
objc.SEL,
args_meta[0].field_type,
args_meta[1].field_type,
args_meta[2].field_type,
) callconv(.C) ReturnType,
4 => fn (
@TypeOf(obj),
objc.SEL,
args_meta[0].field_type,
args_meta[1].field_type,
args_meta[2].field_type,
args_meta[3].field_type,
) callconv(.C) ReturnType,
else => @compileError("[zgpu] Unsupported number of args"),
};
// NOTE: `func` is a var because making it const causes a compile error which I believe is a compiler bug.
var func = @ptrCast(FnType, objc.objc_msgSend);
const sel = objc.sel_getUid(sel_name);
return @call(.{}, func, .{ obj, sel } ++ args);
}
fn printUnhandledError(_: void, typ: gpu.ErrorType, message: [*:0]const u8) void {
switch (typ) {
.validation => std.debug.print("[zgpu] Validation error: {s}\n", .{message}),
.out_of_memory => std.debug.print("[zgpu] Out of memory: {s}\n", .{message}),
.device_lost => std.debug.print("[zgpu] Device lost: {s}\n", .{message}),
.unknown => std.debug.print("[zgpu] Unknown error: {s}\n", .{message}),
else => unreachable,
}
// TODO: Do something better.
std.process.exit(1);
}
var printUnhandledErrorCallback = gpu.ErrorCallback.init(void, {}, printUnhandledError);
fn handleToGpuResourceType(comptime T: type) type {
return switch (T) {
BufferHandle => gpu.Buffer,
TextureHandle => gpu.Texture,
TextureViewHandle => gpu.TextureView,
SamplerHandle => gpu.Sampler,
RenderPipelineHandle => gpu.RenderPipeline,
ComputePipelineHandle => gpu.ComputePipeline,
BindGroupHandle => gpu.BindGroup,
BindGroupLayoutHandle => gpu.BindGroupLayout,
else => @compileError("[zgpu] handleToGpuResourceType() not implemented for " ++ @typeName(T)),
};
}
fn handleToResourceInfoType(comptime T: type) type {
return switch (T) {
BufferHandle => BufferInfo,
TextureHandle => TextureInfo,
TextureViewHandle => TextureViewInfo,
SamplerHandle => SamplerInfo,
RenderPipelineHandle => RenderPipelineInfo,
ComputePipelineHandle => ComputePipelineInfo,
BindGroupHandle => BindGroupInfo,
BindGroupLayoutHandle => BindGroupLayoutInfo,
else => @compileError("[zgpu] handleToResourceInfoType() not implemented for " ++ @typeName(T)),
};
}
| 41.673958 | 117 | 0.604169 |
36484cc8daa986c419d1e1628e16cea44dfaf04e | 3,985 | zig | Zig | src/main.zig | dumheter/zig-imgui-template | ffade94cb6bae3c6ca5ad0d1756a090930a70348 | [
"MIT"
] | 4 | 2021-11-21T23:44:15.000Z | 2022-03-13T21:24:38.000Z | src/main.zig | dumheter/zig-imgui-template | ffade94cb6bae3c6ca5ad0d1756a090930a70348 | [
"MIT"
] | null | null | null | src/main.zig | dumheter/zig-imgui-template | ffade94cb6bae3c6ca5ad0d1756a090930a70348 | [
"MIT"
] | 1 | 2021-12-23T16:27:18.000Z | 2021-12-23T16:27:18.000Z | const std = @import("std");
const c = @import("c.zig").c;
const glfw = @import("glfw");
const theme = @import("theme.zig");
pub fn main() !void {
std.debug.print("-*- zig imgui template -*-\n", .{});
var font: *c.ImFont = undefined;
var run: bool = true;
var display_size = c.ImVec2{
.x = 1280,
.y = 720,
};
// setup glfw & imgui
var window: glfw.Window = undefined;
var context: *c.ImGuiContext = undefined;
var io: *c.ImGuiIO = undefined;
{
try glfw.init(glfw.InitHints{});
window = try glfw.Window.create(
@floatToInt(u32, display_size.x),
@floatToInt(u32, display_size.y),
"zig imgui template",
null,
null,
glfw.Window.Hints{
.context_version_major = 3,
.context_version_minor = 0,
});
try glfw.makeContextCurrent(window);
try glfw.swapInterval(1); // vsync
std.debug.print("imgui version: {s}\n", .{c.igGetVersion()});
context = c.igCreateContext(null);
theme.setImguiTheme(&c.igGetStyle().*.Colors);
if (!c.ImGui_ImplGlfw_InitForOpenGL(@ptrCast(*c.GLFWwindow, window.handle), true)) {
std.debug.panic("", .{});
}
const glsl_version = "#version 130";
if (!c.ImGui_ImplOpenGL3_Init(glsl_version)) {
std.debug.panic("could not init opengl", .{});
}
io = c.igGetIO();
var text_pixels: [*c]u8 = undefined;
var text_w: i32 = undefined;
var text_h: i32 = undefined;
c.ImFontAtlas_GetTexDataAsRGBA32(io.Fonts, &text_pixels, &text_w, &text_h, null);
font = c.ImFontAtlas_AddFontFromFileTTF(io.Fonts, "res/font/CascadiaMonoPL.ttf", 15.0, null, c.ImFontAtlas_GetGlyphRangesDefault(io.Fonts));
_ = c.ImFontAtlas_Build(io.Fonts);
io.DisplaySize = display_size;
io.DeltaTime = 1.0 / 60.0;
}
// run loop
var show_demo_window = false;
while (run) {
if (glfw.pollEvents()) {} else |err| {
std.debug.panic("failed to poll events: {}", .{err});
}
// escape can exit the program
var action: glfw.Action = window.getKey(glfw.Key.escape);
if (action == glfw.Action.press or window.shouldClose()) {
run = false;
}
c.ImGui_ImplOpenGL3_NewFrame();
c.ImGui_ImplGlfw_NewFrame();
c.igNewFrame();
c.igPushFont(font);
///////////////////////////////////////////////////////////////////////////////
// YOUR CODE GOES HERE
{
_ = c.igBegin("Your code goes here", 0, 0);
c.igText("It's this easy to draw text with imgui");
var text_size: c.ImVec2 = undefined;
c.igCalcTextSize(&text_size, "toggle imgui demo", null, true, 1000.0);
if (c.igButton("toggle imgui demo", c.ImVec2{.x = text_size.x + 8, .y = text_size.y + 8})) {
show_demo_window = !show_demo_window;
}
c.igEnd();
}
// draw imgui's demo window
if (show_demo_window) {
c.igShowDemoWindow(&show_demo_window);
}
///////////////////////////////////////////////////////////////////////////////
c.igPopFont();
c.igRender();
if (window.getFramebufferSize()) |size| {
c.glViewport(0, 0, @intCast(c_int, size.width), @intCast(c_int, size.height));
c.glClearColor(0.9, 0.9, 0.9, 0);
c.glClear(c.GL_COLOR_BUFFER_BIT);
c.ImGui_ImplOpenGL3_RenderDrawData(c.igGetDrawData());
} else |err| {
std.debug.panic("failed to get frame buffer size: {}", .{err});
}
if (window.swapBuffers()) {} else |err| {
std.debug.panic("failed to swap buffers: {}", .{err});
}
}
// cleanup
c.igDestroyContext(context);
window.destroy();
glfw.terminate();
}
| 31.132813 | 148 | 0.528482 |
24130ad4289da86c1f254691ce2089dc9fb74869 | 5,754 | zig | Zig | src/Parse.zig | danielabbott/io_uring-HTTPS-Web-Server-WIP- | 30a21eaf5ea0e682698fe448470e53bfd716d38b | [
"MIT"
] | 8 | 2020-06-18T20:22:29.000Z | 2022-02-23T04:55:34.000Z | src/Parse.zig | danielabbott/io_uring-HTTPS-Web-Server-WIP- | 30a21eaf5ea0e682698fe448470e53bfd716d38b | [
"MIT"
] | null | null | null | src/Parse.zig | danielabbott/io_uring-HTTPS-Web-Server-WIP- | 30a21eaf5ea0e682698fe448470e53bfd716d38b | [
"MIT"
] | null | null | null | const std = @import("std");
const assert = std.debug.assert;
const testing = std.testing;
// Returns an error if the end of the string is reached
pub fn skipWhitespace(s: *([]const u8)) !void {
var i: u32 = 0;
while (i < s.*.len and (s.*[i] == ' ' or s.*[i] == '\t' or s.*[i] == '\n' or s.*[i] == '\r')) {
i += 1;
}
if (i == s.*.len) {
return error.EndOfString;
}
s.* = s.*[i..];
}
test "skipWhitespace" {
var s: []const u8 = " \nabc ";
try skipWhitespace(&s);
testing.expect(std.mem.eql(u8, s, "abc "));
}
pub fn skipNewline(s: *([]const u8)) !void {
if (s.*.len == 0) {
return error.EmptyString;
}
if (s.*[0] == '\n') {
s.* = s.*[1..];
} else {
if (s.*.len == 1) {
if (s.*[0] == '\r') {
return error.InvalidNewLine;
}
} else {
// len > 1, first char != '\n'
if (s.*[0] == '\r' and s.*[1] == '\n') {
s.* = s.*[2..];
}
}
}
}
test "skipNewline" {
var s: []const u8 = "\nb";
try skipNewline(&s);
testing.expect(std.mem.eql(u8, s, "b"));
s = "\r\nb";
try skipNewline(&s);
testing.expect(std.mem.eql(u8, s, "b"));
s = "a\r\nb";
try skipNewline(&s);
testing.expect(std.mem.eql(u8, s, "a\r\nb"));
}
// Returns an error if the rest of the string is non-whitespace
pub fn strLenNonWhitespace(s: []const u8) !u32 {
var i: u32 = 0;
while (i < s.len and s[i] != ' ' and s[i] != '\t' and s[i] != '\n' and s[i] != '\r') {
i += 1;
}
if (i == s.len) {
return error.EndOfString;
}
return i;
}
test "strLenNonWhitespace" {
testing.expect((try strLenNonWhitespace("abc\t \t")) == 3);
}
// Returns bytes until next \n or \r\n
pub fn getLineLen(s: []const u8) !u32 {
var i: u32 = 0;
while (i < s.len and s[i] != '\n' and s[i] != '\r') {
i += 1;
}
if (i == s.len) {
return error.EndOfString;
}
return i;
}
test "getLineLen" {
testing.expect((try getLineLen("abc\n")) == 3);
}
pub fn caseInsensitiveStartsWith(s: []const u8, prefix: []const u8) bool {
assert(prefix.len != 0 and s.len != 0);
if (prefix.len > s.len or prefix.len == 0 or s.len == 0) {
return false;
}
var i: u32 = 0;
while (i < prefix.len) : (i += 1) {
if (s[i] == prefix[i]) {
continue;
}
if (s[i] >= 'a' and s[i] < 'z') {
if (prefix[i] != s[i] - ('a' - 'A')) {
return false;
}
} else if (s[i] >= 'A' and s[i] < 'Z') {
if (prefix[i] != s[i] + ('a' - 'A')) {
return false;
}
} else {
return false;
}
}
return true;
}
test "caseInsensitiveStartsWith" {
testing.expect(caseInsensitiveStartsWith("abc\n", "aBc"));
testing.expect(!caseInsensitiveStartsWith("abc\n", "5"));
testing.expect(!caseInsensitiveStartsWith("abc\n", "long string"));
testing.expect(!caseInsensitiveStartsWith("abc\n", " a"));
testing.expect(!caseInsensitiveStartsWith("abc a: def\n", "abc:"));
}
// Ignores end whitespace on s
pub fn caseInsensitiveCompareIgnoreEndWhitespace(s: []const u8, b: []const u8) bool {
if (!caseInsensitiveStartsWith(s, b)) {
return false;
}
if (s.len == b.len) {
return true;
}
var s2 = s[b.len..];
var i: u32 = 0;
while (i < s2.len) : (i += 1) {
if (s2[i] != ' ' and s2[i] != '\t' and s2[i] != '\r' and s2[i] != '\n') {
return false;
}
}
return true;
}
test "caseInsensitiveCompareIgnoreEndWhitespace" {
testing.expect(caseInsensitiveCompareIgnoreEndWhitespace("abc ", "aBc"));
testing.expect(!caseInsensitiveCompareIgnoreEndWhitespace("abc a", "aBc"));
testing.expect(!caseInsensitiveCompareIgnoreEndWhitespace("abcd ", "aBc "));
}
// Returns error when end of string is reached
// Returns null when end of line is reached
// Moves slice to start of next field/line
pub fn getCSVField(s_: *([]const u8)) !?[]const u8 {
if (s_.*.len == 0) {
return error.EndOfString;
}
if (s_.*[0] == '\n') {
s_.* = s_.*[1..];
return null;
}
if (s_.*[0] == '\r') {
if (s_.*.len > 1 and s_.*[1] == '\n') {
s_.* = s_.*[2..];
} else {
s_.* = s_.*[1..];
}
return null;
}
const s = s_.*;
var i: u32 = 0;
while (i < s.len and s[i] != ',' and s[i] != '\n' and s[i] != '\r') {
i += 1;
}
if (i == s.len) {
s_.* = s[s.len - 1 .. s.len - 1];
assert(s_.*.len == 0);
return s;
}
s_.* = s[i..];
if (s_.*[0] == ',') {
s_.* = s_.*[1..];
}
return s[0..i];
}
test "csv" {
var s: []const u8 = "a,b,c\nc,d,eee\n,,f,\n";
testing.expect(std.mem.eql(u8, (try getCSVField(&s)).?, "a"));
testing.expect(std.mem.eql(u8, (try getCSVField(&s)).?, "b"));
testing.expect(std.mem.eql(u8, (try getCSVField(&s)).?, "c"));
testing.expect((try getCSVField(&s)) == null);
try skipWhitespace(&s);
testing.expect(std.mem.eql(u8, (try getCSVField(&s)).?, "c"));
testing.expect(std.mem.eql(u8, (try getCSVField(&s)).?, "d"));
testing.expect(std.mem.eql(u8, (try getCSVField(&s)).?, "eee"));
testing.expect((try getCSVField(&s)) == null);
try skipWhitespace(&s);
testing.expect(std.mem.eql(u8, (try getCSVField(&s)).?, ""));
testing.expect(std.mem.eql(u8, (try getCSVField(&s)).?, ""));
testing.expect(std.mem.eql(u8, (try getCSVField(&s)).?, "f"));
testing.expect((try getCSVField(&s)) == null);
testing.expectError(error.EndOfString, getCSVField(&s));
}
| 27.141509 | 99 | 0.498262 |
1ed807e51d3d37e8bc4ed5845733512e8626152c | 1,484 | zig | Zig | src/res.zig | bootradev/cupcake | 9d4e34837951ada85c3eff02c3948e919fd22e36 | [
"MIT"
] | 11 | 2021-12-28T19:54:26.000Z | 2022-03-31T20:51:11.000Z | src/res.zig | bootradev/cupcake | 9d4e34837951ada85c3eff02c3948e919fd22e36 | [
"MIT"
] | null | null | null | src/res.zig | bootradev/cupcake | 9d4e34837951ada85c3eff02c3948e919fd22e36 | [
"MIT"
] | null | null | null | const api = switch (cfg.platform) {
.web => @import("res_web.zig"),
.win => @compileError("Not yet implemented!"),
};
const cfg = @import("cfg.zig");
const serde = @import("serde.zig");
const std = @import("std");
pub const Res = struct {
Type: type,
data: Data,
pub const Data = union(enum) {
file: struct {
path: []const u8,
size: usize,
},
embed: []const u8,
};
};
pub const LoadDesc = struct {
file_allocator: ?std.mem.Allocator = null,
res_allocator: ?std.mem.Allocator = null,
};
pub fn load(comptime res: Res, desc: LoadDesc) !res.Type {
const bytes_are_embedded = comptime std.meta.activeTag(res.data) == .embed;
const file_bytes = switch (res.data) {
.embed => |e| e,
.file => |f| block: {
if (desc.file_allocator) |allocator| {
break :block try readFile(allocator, f.path, f.size);
} else {
return error.AllocatorRequired;
}
},
};
defer if (!bytes_are_embedded) {
desc.file_allocator.?.free(file_bytes);
};
return try serde.deserialize(
.{ .allocator = desc.res_allocator, .bytes_are_embedded = bytes_are_embedded },
res.Type,
file_bytes,
);
}
pub fn readFile(allocator: std.mem.Allocator, path: []const u8, size: usize) ![]const u8 {
const data = try allocator.alloc(u8, size);
try api.readFile(path, data);
return data;
}
| 26.981818 | 90 | 0.576819 |
af83e7cfe2efdc95a96d49aa8d91baa9cf20e99e | 930 | zig | Zig | build.zig | greenfork/zig-ncurses | 3d3e831631a50ad031e0d51e6d23b154cbf9a2d1 | [
"MIT"
] | 2 | 2021-06-24T19:31:05.000Z | 2021-08-28T19:03:04.000Z | build.zig | greenfork/zig-ncurses | 3d3e831631a50ad031e0d51e6d23b154cbf9a2d1 | [
"MIT"
] | null | null | null | build.zig | greenfork/zig-ncurses | 3d3e831631a50ad031e0d51e6d23b154cbf9a2d1 | [
"MIT"
] | null | null | null | const std = @import("std");
const Builder = std.build.Builder;
const Mode = builtin.Mode;
pub fn build(b: *Builder) void {
const target = b.standardTargetOptions(.{});
const mode = b.standardReleaseOptions();
const example_step = b.step("examples", "Build examples");
inline for (.{
"alternative_charset",
"borders",
"keys",
"mouse",
"printing",
"windows",
}) |name| {
const example = b.addExecutable(name, "examples/" ++ name ++ ".zig");
example.addPackagePath("ncurses", "lib.zig");
example.setBuildMode(mode);
example.setTarget(target);
example.linkLibC();
example.linkSystemLibrary("curses");
example.install();
example_step.dependOn(&example.step);
}
const all_step = b.step("all", "Build everything");
all_step.dependOn(example_step);
b.default_step.dependOn(all_step);
}
| 28.181818 | 77 | 0.606452 |
1b336cf65786987dd0948a162b7100e9fdec9d44 | 153 | zig | Zig | test/compile_errors/stage1/obj/sizeOf_bad_type.zig | damienfir/zig | 1a1b5ee264d8b2219c34d53cc9602692e6d2ba24 | [
"MIT"
] | null | null | null | test/compile_errors/stage1/obj/sizeOf_bad_type.zig | damienfir/zig | 1a1b5ee264d8b2219c34d53cc9602692e6d2ba24 | [
"MIT"
] | null | null | null | test/compile_errors/stage1/obj/sizeOf_bad_type.zig | damienfir/zig | 1a1b5ee264d8b2219c34d53cc9602692e6d2ba24 | [
"MIT"
] | null | null | null | export fn entry() usize {
return @sizeOf(@TypeOf(null));
}
// @sizeOf bad type
//
// tmp.zig:2:20: error: no size available for type '@Type(.Null)'
| 19.125 | 65 | 0.633987 |
ca2a0349f3a5603f9c060280c9c1ac9fdce1769f | 3,553 | zig | Zig | libs/zgpu/src/mach-gpu/Queue.zig | kokizzu/zig-gamedev | 794ede6a00e97f8b7c69d99a88ba1c9cca1db65b | [
"MIT"
] | 1 | 2022-02-14T00:54:13.000Z | 2022-02-14T00:54:13.000Z | libs/zgpu/src/mach-gpu/Queue.zig | hazeycode/zig-gamedev | 16a26020bee836296f1c9a14c78505b42aa87590 | [
"MIT"
] | null | null | null | libs/zgpu/src/mach-gpu/Queue.zig | hazeycode/zig-gamedev | 16a26020bee836296f1c9a14c78505b42aa87590 | [
"MIT"
] | null | null | null | const std = @import("std");
const ImageCopyTexture = @import("structs.zig").ImageCopyTexture;
const Extent3D = @import("data.zig").Extent3D;
const CommandBuffer = @import("CommandBuffer.zig");
const Buffer = @import("Buffer.zig");
const Texture = @import("Texture.zig");
const Queue = @This();
on_submitted_work_done: ?WorkDoneCallback = null,
/// The type erased pointer to the Queue implementation
/// Equal to c.WGPUQueue for NativeInstance.
ptr: *anyopaque,
vtable: *const VTable,
pub const VTable = struct {
reference: fn (ptr: *anyopaque) void,
release: fn (ptr: *anyopaque) void,
// TODO: dawn specific?
// copyTextureForBrowser: fn (ptr: *anyopaque, source: *const ImageCopyTexture, destination: *const ImageCopyTexture, copy_size: *const Extent3D, options: *const CopyTextureForBrowserOptions) void,
submit: fn (queue: Queue, commands: []const CommandBuffer) void,
writeBuffer: fn (
ptr: *anyopaque,
buffer: Buffer,
buffer_offset: u64,
data: *const anyopaque,
size: u64,
) void,
writeTexture: fn (
ptr: *anyopaque,
destination: *const ImageCopyTexture,
data: *const anyopaque,
data_size: usize,
data_layout: *const Texture.DataLayout,
write_size: *const Extent3D,
) void,
};
pub inline fn reference(queue: Queue) void {
queue.vtable.reference(queue.ptr);
}
pub inline fn release(queue: Queue) void {
queue.vtable.release(queue.ptr);
}
pub inline fn submit(queue: Queue, commands: []const CommandBuffer) void {
queue.vtable.submit(queue, commands);
}
pub inline fn writeBuffer(queue: Queue, buffer: Buffer, buffer_offset: u64, comptime T: type, data: []const T) void {
queue.vtable.writeBuffer(
queue.ptr,
buffer,
buffer_offset,
@ptrCast(*const anyopaque, data.ptr),
@intCast(u64, data.len) * @sizeOf(T),
);
}
pub inline fn writeTexture(
queue: Queue,
destination: *const ImageCopyTexture,
data: anytype,
data_layout: *const Texture.DataLayout,
write_size: *const Extent3D,
) void {
queue.vtable.writeTexture(
queue.ptr,
destination,
@ptrCast(*const anyopaque, data.ptr),
@intCast(u64, data.len) * @sizeOf(std.meta.Elem(@TypeOf(data))),
data_layout,
write_size,
);
}
pub const WorkDoneCallback = struct {
type_erased_ctx: *anyopaque,
type_erased_callback: fn (ctx: *anyopaque, status: WorkDoneStatus) callconv(.Inline) void,
pub fn init(
comptime Context: type,
ctx: Context,
comptime callback: fn (ctx: Context, status: WorkDoneStatus) void,
) WorkDoneCallback {
const erased = (struct {
pub inline fn erased(type_erased_ctx: *anyopaque, status: WorkDoneStatus) void {
callback(if (Context == void) {} else @ptrCast(Context, @alignCast(std.meta.alignment(Context), type_erased_ctx)), status);
}
}).erased;
return .{
.type_erased_ctx = if (Context == void) undefined else ctx,
.type_erased_callback = erased,
};
}
};
pub const Descriptor = struct {
label: ?[*:0]const u8 = null,
};
pub const WorkDoneStatus = enum(u32) {
Success = 0x00000000,
Error = 0x00000001,
Unknown = 0x00000002,
DeviceLost = 0x00000003,
Force32 = 0x7FFFFFFF,
};
test {
_ = VTable;
_ = reference;
_ = release;
_ = submit;
_ = writeBuffer;
_ = writeTexture;
_ = WorkDoneCallback;
_ = WorkDoneStatus;
}
| 28.653226 | 201 | 0.645089 |
ba8218014d37acf4c21e06a0da6dad88fa9a4a03 | 6,143 | zig | Zig | source/river-0.1.0/river/Keyboard.zig | Scottx86-64/dotfiles-1 | 51004b1e2b032664cce6b553d2052757c286087d | [
"Unlicense"
] | 1 | 2021-11-20T22:46:39.000Z | 2021-11-20T22:46:39.000Z | source/river-0.1.0/river/Keyboard.zig | Scottx86-64/dotfiles-1 | 51004b1e2b032664cce6b553d2052757c286087d | [
"Unlicense"
] | null | null | null | source/river-0.1.0/river/Keyboard.zig | Scottx86-64/dotfiles-1 | 51004b1e2b032664cce6b553d2052757c286087d | [
"Unlicense"
] | null | null | null | // This file is part of river, a dynamic tiling wayland compositor.
//
// Copyright 2020 The River Developers
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
const Self = @This();
const std = @import("std");
const wlr = @import("wlroots");
const wl = @import("wayland").server.wl;
const xkb = @import("xkbcommon");
const server = &@import("main.zig").server;
const util = @import("util.zig");
const Seat = @import("Seat.zig");
const log = std.log.scoped(.keyboard);
seat: *Seat,
input_device: *wlr.InputDevice,
key: wl.Listener(*wlr.Keyboard.event.Key) = wl.Listener(*wlr.Keyboard.event.Key).init(handleKey),
modifiers: wl.Listener(*wlr.Keyboard) = wl.Listener(*wlr.Keyboard).init(handleModifiers),
destroy: wl.Listener(*wlr.Keyboard) = wl.Listener(*wlr.Keyboard).init(handleDestroy),
pub fn init(self: *Self, seat: *Seat, input_device: *wlr.InputDevice) !void {
self.* = .{
.seat = seat,
.input_device = input_device,
};
// We need to prepare an XKB keymap and assign it to the keyboard. This
// assumes the defaults (e.g. layout = "us").
const rules = xkb.RuleNames{
.rules = null,
.model = null,
.layout = null,
.variant = null,
.options = null,
};
const context = xkb.Context.new(.no_flags) orelse return error.XkbContextFailed;
defer context.unref();
const keymap = xkb.Keymap.newFromNames(context, &rules, .no_flags) orelse return error.XkbKeymapFailed;
defer keymap.unref();
const wlr_keyboard = self.input_device.device.keyboard;
if (!wlr_keyboard.setKeymap(keymap)) return error.SetKeymapFailed;
wlr_keyboard.setRepeatInfo(server.config.repeat_rate, server.config.repeat_delay);
wlr_keyboard.events.key.add(&self.key);
wlr_keyboard.events.modifiers.add(&self.modifiers);
wlr_keyboard.events.destroy.add(&self.destroy);
}
pub fn deinit(self: *Self) void {
self.key.link.remove();
self.modifiers.link.remove();
self.destroy.link.remove();
}
fn handleKey(listener: *wl.Listener(*wlr.Keyboard.event.Key), event: *wlr.Keyboard.event.Key) void {
// This event is raised when a key is pressed or released.
const self = @fieldParentPtr(Self, "key", listener);
const wlr_keyboard = self.input_device.device.keyboard;
self.seat.handleActivity();
self.seat.clearRepeatingMapping();
// Translate libinput keycode -> xkbcommon
const keycode = event.keycode + 8;
// TODO: These modifiers aren't properly handled, see sway's code
const modifiers = wlr_keyboard.getModifiers();
const released = event.state == .released;
var handled = false;
// First check translated keysyms as xkb reports them
for (wlr_keyboard.xkb_state.?.keyGetSyms(keycode)) |sym| {
// Handle builtin mapping only when keys are pressed
if (!released and self.handleBuiltinMapping(sym)) {
handled = true;
break;
} else if (self.seat.handleMapping(sym, modifiers, released)) {
handled = true;
break;
}
}
// If not yet handled, check keysyms ignoring modifiers (e.g. 1 instead of !)
// Important for mappings like Mod+Shift+1
if (!handled) {
const layout_index = wlr_keyboard.xkb_state.?.keyGetLayout(keycode);
for (wlr_keyboard.keymap.?.keyGetSymsByLevel(keycode, layout_index, 0)) |sym| {
// Handle builtin mapping only when keys are pressed
if (!released and self.handleBuiltinMapping(sym)) {
handled = true;
break;
} else if (self.seat.handleMapping(sym, modifiers, released)) {
handled = true;
break;
}
}
}
if (!handled) {
// Otherwise, we pass it along to the client.
const wlr_seat = self.seat.wlr_seat;
wlr_seat.setKeyboard(self.input_device);
wlr_seat.keyboardNotifyKey(event.time_msec, event.keycode, event.state);
}
}
/// Simply pass modifiers along to the client
fn handleModifiers(listener: *wl.Listener(*wlr.Keyboard), wlr_keyboard: *wlr.Keyboard) void {
const self = @fieldParentPtr(Self, "modifiers", listener);
self.seat.wlr_seat.setKeyboard(self.input_device);
self.seat.wlr_seat.keyboardNotifyModifiers(&self.input_device.device.keyboard.modifiers);
}
fn handleDestroy(listener: *wl.Listener(*wlr.Keyboard), wlr_keyboard: *wlr.Keyboard) void {
const self = @fieldParentPtr(Self, "destroy", listener);
const node = @fieldParentPtr(std.TailQueue(Self).Node, "data", self);
self.seat.keyboards.remove(node);
self.deinit();
util.gpa.destroy(node);
}
/// Handle any builtin, harcoded compsitor mappings such as VT switching.
/// Returns true if the keysym was handled.
fn handleBuiltinMapping(self: Self, keysym: xkb.Keysym) bool {
switch (@enumToInt(keysym)) {
@enumToInt(xkb.Keysym.XF86Switch_VT_1)...@enumToInt(xkb.Keysym.XF86Switch_VT_12) => {
log.debug("switch VT keysym received", .{});
if (server.backend.isMulti()) {
if (server.backend.getSession()) |session| {
const vt = @enumToInt(keysym) - @enumToInt(xkb.Keysym.XF86Switch_VT_1) + 1;
const log_server = std.log.scoped(.server);
log_server.notice("switching to VT {}", .{vt});
session.changeVt(vt) catch log_server.err("changing VT failed", .{});
}
}
return true;
},
else => return false,
}
}
| 36.784431 | 107 | 0.660264 |
af1545832dee3b3e558a463ebf9ac75ad36b346e | 173 | zig | Zig | test/cases/catch_at_comptime.0.zig | mparadinha/zig | e498fb155051f548071da1a13098b8793f527275 | [
"MIT"
] | 730 | 2017-04-25T06:34:15.000Z | 2018-05-23T16:11:36.000Z | test/cases/catch_at_comptime.0.zig | mparadinha/zig | e498fb155051f548071da1a13098b8793f527275 | [
"MIT"
] | 691 | 2017-04-25T04:33:29.000Z | 2018-05-23T05:31:49.000Z | test/cases/catch_at_comptime.0.zig | mparadinha/zig | e498fb155051f548071da1a13098b8793f527275 | [
"MIT"
] | 72 | 2017-04-30T14:31:55.000Z | 2018-05-16T22:15:31.000Z | pub fn main() void {
const i: anyerror!u64 = 0;
const caught = i catch 5;
assert(caught == 0);
}
fn assert(b: bool) void {
if (!b) unreachable;
}
// run
//
| 14.416667 | 30 | 0.554913 |
2d4951b8532bbae98da198526a67e41f2c435f6f | 5,646 | zig | Zig | 2021/p03/report.zig | gonzus/AdventOfCode | fe33871b9babe1c93663d468b6c135096c29c4f4 | [
"MIT"
] | null | null | null | 2021/p03/report.zig | gonzus/AdventOfCode | fe33871b9babe1c93663d468b6c135096c29c4f4 | [
"MIT"
] | null | null | null | 2021/p03/report.zig | gonzus/AdventOfCode | fe33871b9babe1c93663d468b6c135096c29c4f4 | [
"MIT"
] | null | null | null | const std = @import("std");
const testing = std.testing;
const allocator = std.testing.allocator;
pub const Report = struct {
const Line = struct {
const MAX_SIZE = 16;
bits: [MAX_SIZE]usize,
alive: bool,
pub fn init() Line {
var self = Line{
.bits = [_]usize{0} ** MAX_SIZE,
.alive = true,
};
return self;
}
pub fn deinit(_: *Line) void {}
pub fn process(self: *Line, line: []const u8) void {
for (line) |c, j| {
self.bits[j] += c - '0';
}
}
pub fn set(self: *Line, bit: usize, value: usize) void {
self.bits[bit] = value;
}
pub fn to_decimal(self: *Line, width: usize) usize {
var num: usize = 0;
for (self.bits) |b, j| {
if (j >= width) break;
num *= 2;
num += b;
}
// std.debug.warn("To decimal {d}: {}\n", .{ self.bits[0..width], num });
return num;
}
};
width: usize,
lines: std.ArrayList(Line),
pub fn init() Report {
var self = Report{
.width = 0,
.lines = std.ArrayList(Line).init(allocator),
};
return self;
}
pub fn deinit(self: *Report) void {
for (self.lines.items) |*line| {
line.deinit();
}
self.lines.deinit();
}
pub fn process_line(self: *Report, data: []const u8) void {
if (data.len == 0) return;
if (self.width == 0) {
self.width = data.len;
}
if (self.width != data.len) {
unreachable;
}
var line = Line.init();
line.process(data);
self.lines.append(line) catch unreachable;
}
pub fn get_power_consumption(self: *Report) usize {
var gamma = Line.init();
defer gamma.deinit();
var epsilon = Line.init();
defer epsilon.deinit();
var j: usize = 0;
while (j < self.width) : (j += 1) {
if (self.has_more_ones_for_bit(j, self.lines.items.len)) {
gamma.set(j, 1);
} else {
epsilon.set(j, 1);
}
}
return gamma.to_decimal(self.width) * epsilon.to_decimal(self.width);
}
pub fn get_life_support_rating(self: *Report) usize {
return self.get_oxygen_generator_rating() * self.get_co2_scrubber_rating();
}
fn reset_alive(self: Report) void {
for (self.lines.items) |*line| {
line.alive = true;
}
}
fn mark_alive_for_bit(self: Report, bit: usize, wanted: usize) usize {
if (bit >= self.width) unreachable;
var count: usize = 0;
for (self.lines.items) |*line| {
if (line.bits[bit] != wanted) {
line.alive = false;
}
if (line.alive) {
// std.debug.warn("Keeping alive line {} bit {}: {d}\n", .{ j, bit, line.bits[0..self.width] });
count += 1;
}
}
return count;
}
fn count_ones_for_bit(self: Report, bit: usize) usize {
if (bit >= self.width) unreachable;
var count: usize = 0;
for (self.lines.items) |*line| {
if (!line.alive) continue;
if (line.bits[bit] != 1) continue;
count += 1;
}
return count;
}
fn has_more_ones_for_bit(self: *Report, bit: usize, size: usize) bool {
const half = (size + 1) / 2;
const count = self.count_ones_for_bit(bit);
return count >= half;
}
fn get_rating(self: *Report, mark: usize) usize {
self.reset_alive();
var j: usize = 0;
var pass: usize = 0;
var left: usize = self.lines.items.len;
while (j < self.width) : (j += 1) {
var count: usize = 0;
if (self.has_more_ones_for_bit(j, left)) {
count = self.mark_alive_for_bit(j, mark);
} else {
count = self.mark_alive_for_bit(j, 1 - mark);
}
if (count == 1) break;
pass += 1;
left = count;
}
for (self.lines.items) |*line| {
if (!line.alive) continue;
return line.to_decimal(self.width);
}
return 0;
}
fn get_oxygen_generator_rating(self: *Report) usize {
return self.get_rating(1);
}
fn get_co2_scrubber_rating(self: *Report) usize {
return self.get_rating(0);
}
};
test "sample part a" {
const data: []const u8 =
\\00100
\\11110
\\10110
\\10111
\\10101
\\01111
\\00111
\\11100
\\10000
\\11001
\\00010
\\01010
;
var report = Report.init();
defer report.deinit();
var it = std.mem.split(u8, data, "\n");
while (it.next()) |line| {
report.process_line(line);
}
const pc = report.get_power_consumption();
try testing.expect(pc == 198);
}
test "sample part b" {
const data: []const u8 =
\\00100
\\11110
\\10110
\\10111
\\10101
\\01111
\\00111
\\11100
\\10000
\\11001
\\00010
\\01010
;
var report = Report.init();
defer report.deinit();
var it = std.mem.split(u8, data, "\n");
while (it.next()) |line| {
report.process_line(line);
}
const lsr = report.get_life_support_rating();
try testing.expect(lsr == 230);
}
| 25.093333 | 112 | 0.482643 |
3334ca2d61209af82a6138124f37435391232a0a | 2,506 | zig | Zig | src/util/enums.zig | tsmanner/table-top | b7affa8117bb1b13db8449a2578dce3becd0855d | [
"MIT"
] | null | null | null | src/util/enums.zig | tsmanner/table-top | b7affa8117bb1b13db8449a2578dce3becd0855d | [
"MIT"
] | null | null | null | src/util/enums.zig | tsmanner/table-top | b7affa8117bb1b13db8449a2578dce3becd0855d | [
"MIT"
] | null | null | null | const std = @import("std");
pub fn Combinator(comptime Left: type, comptime Right: type) type {
return struct {
const Self = @This();
/// Take two enum types and yield a new enum that contains the cross product of them.
/// Enum values are ignored to guarantee there are no collisions.
/// Names are directly concatenated, left ++ right.
pub const Cross = blk: {
const lefts = std.meta.fields(Left);
const rights = std.meta.fields(Right);
var enumFields: [lefts.len * rights.len]std.builtin.TypeInfo.EnumField = undefined;
var decls = [_]std.builtin.TypeInfo.Declaration{};
var i: usize = 0;
inline for (lefts) |left, li| {
if (left.value != li) {
@compileLog(Left, left.name, left.value);
@compileError("Enums must not override ordinal values");
}
inline for (rights) |right, ri| {
if (right.value != ri) {
@compileLog(Right, right.name, right.value);
@compileError("Enums must not override ordinal values");
}
enumFields[i] = .{
.name = left.name ++ right.name,
.value = i,
};
i += 1;
}
}
break :blk @Type(.{
.Enum = .{
.layout = .Auto,
.tag_type = std.math.IntFittingRange(0, i - 1),
.fields = &enumFields,
.decls = &decls,
.is_exhaustive = true,
},
});
};
/// Yield the cross-product value of two comptime-known enum values
pub fn cross(left: Left, right: Right) Self.Cross {
return @intToEnum(Self.Cross, @enumToInt(left) * std.meta.fields(Right).len + @enumToInt(right));
}
};
}
test "Cross" {
const E1 = enum(u3) { x, y };
const E2 = enum { a, b };
const E1E2 = Combinator(E1, E2);
const names = std.meta.fieldNames(E1E2.Cross);
try std.testing.expectEqualStrings("xa", names[0]);
try std.testing.expectEqualStrings("xb", names[1]);
try std.testing.expectEqualStrings("ya", names[2]);
try std.testing.expectEqualStrings("yb", names[3]);
try std.testing.expectEqual(@enumToInt(E1E2.cross(.x, .b)), @enumToInt(E1E2.Cross.xb));
}
| 40.419355 | 109 | 0.509577 |
88283231f8090de924ed65525b17f82bce263c8a | 6,313 | zig | Zig | src/day12.zig | cdwfs/advent2021 | b1763165a69fccffd7ed12f80c5f4d6ce5f3e25e | [
"MIT"
] | 4 | 2021-12-30T09:40:02.000Z | 2022-01-04T02:36:12.000Z | src/day12.zig | cdwfs/advent2021 | b1763165a69fccffd7ed12f80c5f4d6ce5f3e25e | [
"MIT"
] | null | null | null | src/day12.zig | cdwfs/advent2021 | b1763165a69fccffd7ed12f80c5f4d6ce5f3e25e | [
"MIT"
] | null | null | null | const std = @import("std");
const util = @import("util.zig");
const data = @embedFile("../data/day12.txt");
const Input = struct {
nodes: std.StringHashMap(std.ArrayList([]const u8)),
node_masks: std.StringHashMap(u25),
allocator: std.mem.Allocator,
pub fn init(input_text: []const u8, allocator: std.mem.Allocator) !@This() {
var input = Input{
.nodes = std.StringHashMap(std.ArrayList([]const u8)).init(allocator),
.node_masks = std.StringHashMap(u25).init(allocator),
.allocator = allocator,
};
errdefer input.deinit();
try input.nodes.ensureTotalCapacity(25);
try input.node_masks.ensureTotalCapacity(25);
var lines = std.mem.tokenize(u8, input_text, "\r\n");
var node_count: u5 = 0;
while (lines.next()) |line| {
var kv = std.mem.tokenize(u8, line, "-");
const node1 = kv.next().?;
const node2 = kv.next().?;
if (input.nodes.getOrPut(node1)) |result| {
if (!result.found_existing) {
result.value_ptr.* = try std.ArrayList([]const u8).initCapacity(input.allocator, 25);
try input.node_masks.put(node1, @as(u25, 1) << node_count);
node_count += 1;
}
try result.value_ptr.append(node2);
} else |_| {
print("GetOrPut error\n", .{});
}
// TODO: do it again
if (input.nodes.getOrPut(node2)) |result| {
if (!result.found_existing) {
result.value_ptr.* = try std.ArrayList([]const u8).initCapacity(input.allocator, 25);
try input.node_masks.put(node2, @as(u25, 1) << node_count);
node_count += 1;
}
try result.value_ptr.append(node1);
} else |_| {
print("GetOrPut error\n", .{});
}
}
return input;
}
pub fn deinit(self: *@This()) void {
var itor = self.nodes.valueIterator();
while (itor.next()) |val| {
val.deinit();
}
self.nodes.deinit();
self.node_masks.deinit();
}
};
fn numPathsToEnd(input: Input, node: []const u8, visited: u25, can_visit_twice: bool) i64 {
if (std.mem.eql(u8, node, "end")) {
return 1;
}
var new_visited = visited;
var new_can_visit_twice = can_visit_twice;
if (std.ascii.isLower(node[0])) {
const mask = input.node_masks.get(node).?;
assert(mask != 0);
if ((new_visited & mask) != 0) {
// we've already been here. Can we visit twice?
if (!new_can_visit_twice or std.mem.eql(u8, node, "start")) {
return 0; // can't visit this node twice
}
new_can_visit_twice = false; // no more double-visits on this path
}
new_visited |= mask; // mark node as visited
}
var sum: i64 = 0;
const neighbors = input.nodes.get(node).?;
for (neighbors.items) |neighbor| {
sum += numPathsToEnd(input, neighbor, new_visited, new_can_visit_twice);
}
return sum;
}
fn part1(input: Input) i64 {
return numPathsToEnd(input, "start", 0, false);
}
fn part2(input: Input) i64 {
return numPathsToEnd(input, "start", 0, true);
}
const test_data =
\\start-A
\\start-b
\\A-c
\\A-b
\\b-d
\\A-end
\\b-end
;
const part1_test_solution: ?i64 = 10;
const part1_solution: ?i64 = 4720;
const part2_test_solution: ?i64 = 36;
const part2_solution: ?i64 = 147848;
const test_data2 =
\\dc-end
\\HN-start
\\start-kj
\\dc-start
\\dc-HN
\\LN-dc
\\HN-end
\\kj-sa
\\kj-HN
\\kj-dc
;
const test_data3 =
\\fs-end
\\he-DX
\\fs-he
\\start-DX
\\pj-DX
\\end-zg
\\zg-sl
\\zg-pj
\\pj-he
\\RW-he
\\fs-DX
\\pj-RW
\\zg-RW
\\start-pj
\\he-WI
\\zg-he
\\pj-fs
\\start-RW
;
// Just boilerplate below here, nothing to see
fn testPart1() !void {
var test_input = try Input.init(test_data, std.testing.allocator);
defer test_input.deinit();
if (part1_test_solution) |solution| {
try std.testing.expectEqual(solution, part1(test_input));
}
var test_input2 = try Input.init(test_data2, std.testing.allocator);
defer test_input2.deinit();
try std.testing.expectEqual(@as(i64, 19), part1(test_input2));
var test_input3 = try Input.init(test_data3, std.testing.allocator);
defer test_input3.deinit();
try std.testing.expectEqual(@as(i64, 226), part1(test_input3));
var timer = try std.time.Timer.start();
var input = try Input.init(data, std.testing.allocator);
defer input.deinit();
if (part1_solution) |solution| {
try std.testing.expectEqual(solution, part1(input));
print("part1 took {d:9.3}ms\n", .{@intToFloat(f64, timer.lap()) / 1000000.0});
}
}
fn testPart2() !void {
var test_input = try Input.init(test_data, std.testing.allocator);
defer test_input.deinit();
if (part2_test_solution) |solution| {
try std.testing.expectEqual(solution, part2(test_input));
}
var test_input2 = try Input.init(test_data2, std.testing.allocator);
defer test_input2.deinit();
try std.testing.expectEqual(@as(i64, 103), part2(test_input2));
var test_input3 = try Input.init(test_data3, std.testing.allocator);
defer test_input3.deinit();
try std.testing.expectEqual(@as(i64, 3509), part2(test_input3));
var timer = try std.time.Timer.start();
var input = try Input.init(data, std.testing.allocator);
defer input.deinit();
if (part2_solution) |solution| {
try std.testing.expectEqual(solution, part2(input));
print("part2 took {d:9.3}ms\n", .{@intToFloat(f64, timer.lap()) / 1000000.0});
}
}
pub fn main() !void {
try testPart1();
try testPart2();
}
test "part1" {
try testPart1();
}
test "part2" {
try testPart2();
}
// Useful stdlib functions
const tokenize = std.mem.tokenize;
const split = std.mem.split;
const parseInt = std.fmt.parseInt;
const min = std.math.min;
const max = std.math.max;
const print = std.debug.print;
const expect = std.testing.expect;
const assert = std.debug.assert;
| 29.226852 | 105 | 0.586251 |
306a99b39f9249f004ed0032a13273069620307e | 2,297 | zig | Zig | src/de/impl/visitor/array.zig | demizer/getty | 4fd923bdd5487ca080cf8bb13d4f3023c4033c83 | [
"MIT"
] | null | null | null | src/de/impl/visitor/array.zig | demizer/getty | 4fd923bdd5487ca080cf8bb13d4f3023c4033c83 | [
"MIT"
] | null | null | null | src/de/impl/visitor/array.zig | demizer/getty | 4fd923bdd5487ca080cf8bb13d4f3023c4033c83 | [
"MIT"
] | null | null | null | const getty = @import("../../../lib.zig");
const std = @import("std");
pub fn Visitor(comptime Array: type) type {
return struct {
const Self = @This();
pub usingnamespace getty.de.Visitor(
Self,
Value,
undefined,
undefined,
undefined,
undefined,
undefined,
undefined,
visitSeq,
visitString,
undefined,
undefined,
);
const Value = Array;
fn visitSeq(_: Self, allocator: ?std.mem.Allocator, comptime Deserializer: type, seq: anytype) Deserializer.Error!Value {
var array: Value = undefined;
var seen: usize = 0;
errdefer {
if (allocator) |alloc| {
if (array.len > 0) {
var i: usize = 0;
while (i < seen) : (i += 1) {
getty.de.free(alloc, array[i]);
}
}
}
}
switch (array.len) {
0 => array = .{},
else => for (array) |*elem| {
if (try seq.nextElement(allocator, Child)) |value| {
elem.* = value;
seen += 1;
} else {
// End of sequence was reached early.
return error.InvalidLength;
}
},
}
// Expected end of sequence, but found an element.
if ((try seq.nextElement(allocator, Child)) != null) {
return error.InvalidLength;
}
return array;
}
fn visitString(_: Self, allocator: ?std.mem.Allocator, comptime Deserializer: type, input: anytype) Deserializer.Error!Value {
defer getty.de.free(allocator.?, input);
if (Child == u8) {
var string: Value = undefined;
if (input.len == string.len) {
std.mem.copy(u8, &string, input);
return string;
}
}
return error.InvalidType;
}
const Child = std.meta.Child(Value);
};
}
| 28.7125 | 134 | 0.422725 |
0bf02ca1c4f4d2f0d69d00b2550fca2f5380e89c | 1,413 | zig | Zig | example/meta_random.zig | NewbLuck/zig-wren | cdb4ee342c00ce17518720333a8d07203d78bdd2 | [
"MIT"
] | 2 | 2022-03-12T19:38:44.000Z | 2022-03-12T19:58:27.000Z | example/meta_random.zig | NewbLuck/zig-wren | cdb4ee342c00ce17518720333a8d07203d78bdd2 | [
"MIT"
] | null | null | null | example/meta_random.zig | NewbLuck/zig-wren | cdb4ee342c00ce17518720333a8d07203d78bdd2 | [
"MIT"
] | 2 | 2021-08-04T09:35:33.000Z | 2021-08-04T17:13:23.000Z | const std = @import("std");
const wren = @import("wren");
pub var alloc = std.testing.allocator;
pub fn main() anyerror!void {
// Initialize the data structures for the wrapper
wren.init(alloc);
defer wren.deinit();
// Set up a VM configuration using the supplied default bindings
// You can override the bindings after calling this to change them
var config = wren.util.defaultConfig();
// Create a new VM from our config we generated previously
const vm = wren.newVM(&config);
defer wren.freeVM(vm);
// Test the optional 'Meta' module
// Using Meta.eval to interpret Wren source from Wren
try wren.util.run(vm,"main",
\\ import "meta" for Meta
\\
\\ var a = 2
\\ var b = 3
\\ var source = """
\\ var c = a * b
\\ System.print(c)
\\ """
\\ Meta.eval(source)
);
// Test the optional 'Random' module
// Test the evenness of the random distribution
try wren.util.run(vm,"main",
\\ import "random" for Random
\\
\\ var random = Random.new(12345)
\\
\\ var below = 0
\\ for (i in 1..1000) {
\\ var n = random.int()
\\ if (n < 2147483648) below = below + 1
\\ }
\\
\\ System.print(below > 450) // expect: true
\\ System.print(below < 550) // expect: true
);
}
| 27.705882 | 70 | 0.547771 |
6c54829eadee9c4523b904078c4191e82d9b7e46 | 1,702 | zig | Zig | src/Route.zig | 06kellyjac/libflightplan | d75ae9a98f137f2f64dc963888e548fa552b6209 | [
"MIT"
] | 63 | 2022-01-16T18:43:40.000Z | 2022-03-25T17:23:21.000Z | src/Route.zig | 06kellyjac/libflightplan | d75ae9a98f137f2f64dc963888e548fa552b6209 | [
"MIT"
] | 1 | 2022-01-21T17:33:39.000Z | 2022-01-23T05:01:03.000Z | src/Route.zig | 06kellyjac/libflightplan | d75ae9a98f137f2f64dc963888e548fa552b6209 | [
"MIT"
] | 2 | 2022-01-17T13:35:52.000Z | 2022-01-20T16:01:04.000Z | /// Route structure represents an ordered list of waypoints (and other
/// potential metadata) for a route in a flight plan.
const Self = @This();
const std = @import("std");
const Allocator = std.mem.Allocator;
const PointsList = std.ArrayListUnmanaged(Point);
/// Name of the route, human-friendly.
name: ?[:0]const u8 = null,
/// Ordered list of points in the route. Currently, each value is a string
/// matching the name of a Waypoint. In the future, this will be changed
/// to a rich struct that has more information.
points: PointsList = .{},
/// Point is a point in a route.
pub const Point = struct {
/// Identifier of this route point, MUST correspond to a matching
/// waypoint in the flight plan or most encoding will fail.
identifier: [:0]const u8,
/// The route that this point is via, such as an airway. This is used
/// by certain formats and ignored by most.
via: ?Via = null,
/// Altitude in feet (MSL, AGL, whatever you'd like for your flight
/// plan and format). This is used by some formats to note the desired
/// altitude at a given point. This can be zero to note cruising altitude
/// or field elevation.
altitude: u16 = 0,
pub const Via = union(enum) {
airport_departure: void,
airport_destination: void,
direct: void,
airway: [:0]const u8,
};
pub fn deinit(self: *Point, alloc: Allocator) void {
alloc.free(self.identifier);
self.* = undefined;
}
};
pub fn deinit(self: *Self, alloc: Allocator) void {
if (self.name) |v| alloc.free(v);
while (self.points.popOrNull()) |*v| v.deinit(alloc);
self.points.deinit(alloc);
self.* = undefined;
}
| 32.113208 | 77 | 0.658637 |
225a1e208c2ff23d2380cb29d4dca4d2fe25b7e4 | 4,439 | zig | Zig | lib/std/fmt/parse_float/convert_slow.zig | mparadinha/zig | e498fb155051f548071da1a13098b8793f527275 | [
"MIT"
] | 730 | 2017-04-25T06:34:15.000Z | 2018-05-23T16:11:36.000Z | lib/std/fmt/parse_float/convert_slow.zig | mparadinha/zig | e498fb155051f548071da1a13098b8793f527275 | [
"MIT"
] | 691 | 2017-04-25T04:33:29.000Z | 2018-05-23T05:31:49.000Z | lib/std/fmt/parse_float/convert_slow.zig | mparadinha/zig | e498fb155051f548071da1a13098b8793f527275 | [
"MIT"
] | 72 | 2017-04-30T14:31:55.000Z | 2018-05-16T22:15:31.000Z | const std = @import("std");
const math = std.math;
const common = @import("common.zig");
const BiasedFp = common.BiasedFp;
const Decimal = @import("decimal.zig").Decimal;
const mantissaType = common.mantissaType;
const max_shift = 60;
const num_powers = 19;
const powers = [_]u8{ 0, 3, 6, 9, 13, 16, 19, 23, 26, 29, 33, 36, 39, 43, 46, 49, 53, 56, 59 };
pub fn getShift(n: usize) usize {
return if (n < num_powers) powers[n] else max_shift;
}
/// Parse the significant digits and biased, binary exponent of a float.
///
/// This is a fallback algorithm that uses a big-integer representation
/// of the float, and therefore is considerably slower than faster
/// approximations. However, it will always determine how to round
/// the significant digits to the nearest machine float, allowing
/// use to handle near half-way cases.
///
/// Near half-way cases are halfway between two consecutive machine floats.
/// For example, the float `16777217.0` has a bitwise representation of
/// `100000000000000000000000 1`. Rounding to a single-precision float,
/// the trailing `1` is truncated. Using round-nearest, tie-even, any
/// value above `16777217.0` must be rounded up to `16777218.0`, while
/// any value before or equal to `16777217.0` must be rounded down
/// to `16777216.0`. These near-halfway conversions therefore may require
/// a large number of digits to unambiguously determine how to round.
///
/// The algorithms described here are based on "Processing Long Numbers Quickly",
/// available here: <https://arxiv.org/pdf/2101.11408.pdf#section.11>.
pub fn convertSlow(comptime T: type, s: []const u8) BiasedFp(T) {
const MantissaT = mantissaType(T);
const min_exponent = -(1 << (math.floatExponentBits(T) - 1)) + 1;
const infinite_power = (1 << math.floatExponentBits(T)) - 1;
const mantissa_explicit_bits = math.floatMantissaBits(T);
var d = Decimal(T).parse(s); // no need to recheck underscores
if (d.num_digits == 0 or d.decimal_point < Decimal(T).min_exponent) {
return BiasedFp(T).zero();
} else if (d.decimal_point >= Decimal(T).max_exponent) {
return BiasedFp(T).inf(T);
}
var exp2: i32 = 0;
// Shift right toward (1/2 .. 1]
while (d.decimal_point > 0) {
const n = @intCast(usize, d.decimal_point);
const shift = getShift(n);
d.rightShift(shift);
if (d.decimal_point < -Decimal(T).decimal_point_range) {
return BiasedFp(T).zero();
}
exp2 += @intCast(i32, shift);
}
// Shift left toward (1/2 .. 1]
while (d.decimal_point <= 0) {
const shift = blk: {
if (d.decimal_point == 0) {
break :blk switch (d.digits[0]) {
5...9 => break,
0, 1 => @as(usize, 2),
else => 1,
};
} else {
const n = @intCast(usize, -d.decimal_point);
break :blk getShift(n);
}
};
d.leftShift(shift);
if (d.decimal_point > Decimal(T).decimal_point_range) {
return BiasedFp(T).inf(T);
}
exp2 -= @intCast(i32, shift);
}
// We are now in the range [1/2 .. 1] but the binary format uses [1 .. 2]
exp2 -= 1;
while (min_exponent + 1 > exp2) {
var n = @intCast(usize, (min_exponent + 1) - exp2);
if (n > max_shift) {
n = max_shift;
}
d.rightShift(n);
exp2 += @intCast(i32, n);
}
if (exp2 - min_exponent >= infinite_power) {
return BiasedFp(T).inf(T);
}
// Shift the decimal to the hidden bit, and then round the value
// to get the high mantissa+1 bits.
d.leftShift(mantissa_explicit_bits + 1);
var mantissa = d.round();
if (mantissa >= (@as(MantissaT, 1) << (mantissa_explicit_bits + 1))) {
// Rounding up overflowed to the carry bit, need to
// shift back to the hidden bit.
d.rightShift(1);
exp2 += 1;
mantissa = d.round();
if ((exp2 - min_exponent) >= infinite_power) {
return BiasedFp(T).inf(T);
}
}
var power2 = exp2 - min_exponent;
if (mantissa < (@as(MantissaT, 1) << mantissa_explicit_bits)) {
power2 -= 1;
}
// Zero out all the bits above the explicit mantissa bits.
mantissa &= (@as(MantissaT, 1) << mantissa_explicit_bits) - 1;
return .{ .f = mantissa, .e = power2 };
}
| 38.6 | 95 | 0.60419 |
c324933806d806399cdaf79536a148048c333d65 | 12,878 | zig | Zig | src/kernel/arch/x86_64/limine/stivale2/stivale2.zig | davidgm94/RNU | 249bfc97ab215318270e6f54e4fea314f33b02e8 | [
"CC0-1.0"
] | null | null | null | src/kernel/arch/x86_64/limine/stivale2/stivale2.zig | davidgm94/RNU | 249bfc97ab215318270e6f54e4fea314f33b02e8 | [
"CC0-1.0"
] | null | null | null | src/kernel/arch/x86_64/limine/stivale2/stivale2.zig | davidgm94/RNU | 249bfc97ab215318270e6f54e4fea314f33b02e8 | [
"CC0-1.0"
] | null | null | null | const std = @import("std");
const assert = std.debug.assert;
const stivale = @import("header.zig");
const log = std.log.scoped(.stivale2);
const kernel = @import("../../../../kernel.zig");
const x86_64 = @import("../../../x86_64.zig");
pub const Struct = stivale.Struct;
pub const Error = error{
memory_map,
higher_half_direct_map,
kernel_file,
pmrs,
rsdp,
smp,
};
pub fn process_bootloader_information(stivale2_struct: *Struct) Error!void {
kernel.sections_in_memory = try process_pmrs(stivale2_struct);
log.debug("Process sections in memory", .{});
kernel.file = try process_kernel_file(stivale2_struct);
log.debug("Process kernel file in memory", .{});
kernel.cpus = try process_smp(stivale2_struct);
log.debug("Process SMP info", .{});
}
pub fn find(comptime StructT: type, stivale2_struct: *Struct) ?*align(1) StructT {
var tag_opt = get_tag_from_physical(kernel.Physical.Address.new(stivale2_struct.tags));
while (tag_opt) |tag| {
if (tag.identifier == StructT.id) {
return @ptrCast(*align(1) StructT, tag);
}
tag_opt = get_tag_from_physical(kernel.Physical.Address.new(tag.next));
}
return null;
}
fn get_tag_from_physical(physical_address: kernel.Physical.Address) ?*align(1) stivale.Tag {
return if (kernel.Virtual.initialized) physical_address.access_higher_half(?*align(1) stivale.Tag) else physical_address.access_identity(?*align(1) stivale.Tag);
}
pub fn process_memory_map(stivale2_struct: *Struct) Error!kernel.Physical.Memory.Map {
const memory_map_struct = find(Struct.MemoryMap, stivale2_struct) orelse return Error.memory_map;
const memory_map_entries = memory_map_struct.memmap()[0..memory_map_struct.entry_count];
var result = kernel.Physical.Memory.Map{
.usable = &[_]kernel.Physical.Memory.Map.Entry{},
.reclaimable = &[_]kernel.Physical.Memory.Map.Entry{},
.framebuffer = &[_]kernel.Physical.Memory.Region{},
.kernel_and_modules = &[_]kernel.Physical.Memory.Region{},
.reserved = &[_]kernel.Physical.Memory.Region{},
};
// First, it is required to find a spot in memory big enough to host all the memory map entries in a architecture-independent and bootloader-independent way. This is the host entry
const host_entry = blk: {
for (memory_map_entries) |*entry| {
if (entry.type == .usable) {
const bitset = kernel.Physical.Memory.Map.Entry.get_bitset_from_address_and_size(kernel.Physical.Address.new(entry.address), entry.size);
const bitset_size = bitset.len * @sizeOf(kernel.Physical.Memory.Map.Entry.BitsetBaseType);
// INFO: this is separated since the bitset needs to be in a different page than the memory map
const bitset_page_count = kernel.bytes_to_pages(bitset_size, false);
// Allocate a bit more memory than needed just in case
const memory_map_allocation_size = memory_map_struct.entry_count * @sizeOf(kernel.Physical.Memory.Map.Entry);
const memory_map_page_count = kernel.bytes_to_pages(memory_map_allocation_size, false);
const total_allocated_page_count = bitset_page_count + memory_map_page_count;
const total_allocation_size = kernel.arch.page_size * total_allocated_page_count;
kernel.assert(@src(), entry.size > total_allocation_size);
result.usable = @intToPtr([*]kernel.Physical.Memory.Map.Entry, entry.address + kernel.align_forward(bitset_size, kernel.arch.page_size))[0..1];
var block = &result.usable[0];
block.* = kernel.Physical.Memory.Map.Entry{
.descriptor = kernel.Physical.Memory.Region{
.address = kernel.Physical.Address.new(entry.address),
.size = entry.size,
},
.allocated_size = total_allocation_size,
.type = .usable,
};
block.setup_bitset();
break :blk block;
}
}
@panic("There is no memory map entry big enough to store the memory map entries");
};
// The counter starts with one because we have already filled the memory map with the host entry
for (memory_map_entries) |*entry| {
if (entry.type == .usable) {
if (entry.address == host_entry.descriptor.address.value) continue;
const index = result.usable.len;
result.usable.len += 1;
var result_entry = &result.usable[index];
result_entry.* = kernel.Physical.Memory.Map.Entry{
.descriptor = kernel.Physical.Memory.Region{
.address = kernel.Physical.Address.new(entry.address),
.size = entry.size,
},
.allocated_size = 0,
.type = .usable,
};
const bitset = result_entry.get_bitset();
const bitset_size = bitset.len * @sizeOf(kernel.Physical.Memory.Map.Entry.BitsetBaseType);
result_entry.allocated_size = kernel.align_forward(bitset_size, kernel.arch.page_size);
result_entry.setup_bitset();
}
}
result.reclaimable.ptr = @intToPtr(@TypeOf(result.reclaimable.ptr), @ptrToInt(result.usable.ptr) + (@sizeOf(kernel.Physical.Memory.Map.Entry) * result.usable.len));
for (memory_map_entries) |*entry| {
if (entry.type == .bootloader_reclaimable) {
const index = result.reclaimable.len;
result.reclaimable.len += 1;
var result_entry = &result.reclaimable[index];
result_entry.* = kernel.Physical.Memory.Map.Entry{
.descriptor = kernel.Physical.Memory.Region{
.address = kernel.Physical.Address.new(entry.address),
.size = entry.size,
},
.allocated_size = 0,
.type = .reclaimable,
};
// Don't use the bitset here because it would imply using memory that may not be usable at the moment of writing the bitset to this region
}
}
result.framebuffer.ptr = @intToPtr(@TypeOf(result.framebuffer.ptr), @ptrToInt(result.reclaimable.ptr) + (@sizeOf(kernel.Physical.Memory.Map.Entry) * result.reclaimable.len));
for (memory_map_entries) |*entry| {
if (entry.type == .framebuffer) {
const index = result.framebuffer.len;
result.framebuffer.len += 1;
var result_entry = &result.framebuffer[index];
result_entry.* = kernel.Physical.Memory.Region{
.address = kernel.Physical.Address.new(entry.address),
.size = entry.size,
};
// Don't use the bitset here because it would imply using memory that may not be usable at the moment of writing the bitset to this region
}
}
result.kernel_and_modules.ptr = @intToPtr(@TypeOf(result.kernel_and_modules.ptr), @ptrToInt(result.framebuffer.ptr) + (@sizeOf(kernel.Physical.Memory.Region) * result.framebuffer.len));
for (memory_map_entries) |*entry| {
if (entry.type == .kernel_and_modules) {
const index = result.kernel_and_modules.len;
result.kernel_and_modules.len += 1;
var result_entry = &result.kernel_and_modules[index];
result_entry.* = kernel.Physical.Memory.Region{
.address = kernel.Physical.Address.new(entry.address),
.size = entry.size,
};
// Don't use the bitset here because it would imply using memory that may not be usable at the moment of writing the bitset to this region
}
}
kernel.assert(@src(), result.kernel_and_modules.len == 1);
result.reserved.ptr = @intToPtr(@TypeOf(result.reserved.ptr), @ptrToInt(result.kernel_and_modules.ptr) + (@sizeOf(kernel.Physical.Memory.Region) * result.kernel_and_modules.len));
for (memory_map_entries) |*entry| {
if (entry.type == .reserved) {
const index = result.reserved.len;
result.reserved.len += 1;
var result_entry = &result.reserved[index];
result_entry.* = kernel.Physical.Memory.Region{
.address = kernel.Physical.Address.new(entry.address),
.size = entry.size,
};
// Don't use the bitset here because it would imply using memory that may not be usable at the moment of writing the bitset to this region
}
}
log.debug("Memory map initialized", .{});
return result;
}
pub fn process_higher_half_direct_map(stivale2_struct: *Struct) Error!kernel.Virtual.Address {
const hhdm_struct = find(Struct.HHDM, stivale2_struct) orelse return Error.higher_half_direct_map;
log.debug("HHDM: 0x{x}", .{hhdm_struct.addr});
return kernel.Virtual.Address.new(hhdm_struct.addr);
}
pub fn process_pmrs(stivale2_struct: *Struct) Error![]kernel.Virtual.Memory.RegionWithPermissions {
log.debug("Here", .{});
const pmrs_struct = find(stivale.Struct.PMRs, stivale2_struct) orelse return Error.pmrs;
log.debug("PMRS struct: 0x{x}", .{@ptrToInt(pmrs_struct)});
const pmrs = pmrs_struct.pmrs()[0..pmrs_struct.entry_count];
if (pmrs.len == 0) return Error.pmrs;
log.debug("past this", .{});
kernel.assert(@src(), kernel.Virtual.initialized);
const kernel_section_allocation_size = kernel.align_forward(@sizeOf(kernel.Virtual.Memory.RegionWithPermissions) * pmrs.len, kernel.arch.page_size);
const kernel_section_allocation = kernel.address_space.allocate(kernel_section_allocation_size) orelse return Error.pmrs;
const kernel_sections = kernel_section_allocation.access([*]kernel.Virtual.Memory.RegionWithPermissions)[0..pmrs.len];
for (pmrs) |pmr, i| {
const kernel_section = &kernel_sections[i];
kernel_section.descriptor.address = kernel.Virtual.Address.new(pmr.address);
kernel_section.descriptor.size = pmr.size;
const permissions = pmr.permissions;
kernel_section.read = permissions & (1 << stivale.Struct.PMRs.PMR.readable) != 0;
kernel_section.write = permissions & (1 << stivale.Struct.PMRs.PMR.writable) != 0;
kernel_section.execute = permissions & (1 << stivale.Struct.PMRs.PMR.executable) != 0;
}
return kernel_sections;
}
pub fn get_pmrs(stivale2_struct: *Struct) []Struct.PMRs.PMR {
const pmrs_struct = find(stivale.Struct.PMRs, stivale2_struct) orelse unreachable;
const pmrs = pmrs_struct.pmrs()[0..pmrs_struct.entry_count];
return pmrs;
}
/// This procedure copies the kernel file in a region which is usable and whose allocationcan be registered in the physical allocator bitset
pub fn process_kernel_file(stivale2_struct: *Struct) Error!kernel.File {
kernel.assert(@src(), kernel.Virtual.initialized);
const kernel_file = find(stivale.Struct.KernelFileV2, stivale2_struct) orelse return Error.kernel_file;
const file_address = kernel.Physical.Address.new(kernel_file.kernel_file);
const file_size = kernel_file.kernel_size;
const allocation = kernel.address_space.allocate(kernel.align_forward(file_size, kernel.arch.page_size)) orelse return Error.kernel_file;
const dst = allocation.access([*]u8)[0..file_size];
const src = file_address.access_higher_half([*]u8)[0..file_size];
log.debug("Copying kernel file to (0x{x}, 0x{x})", .{ @ptrToInt(dst.ptr), @ptrToInt(dst.ptr) + dst.len });
kernel.copy(u8, dst, src);
return kernel.File{
.address = allocation,
.size = file_size,
};
}
pub fn process_rsdp(stivale2_struct: *Struct) Error!kernel.Physical.Address {
const rsdp_struct = find(stivale.Struct.RSDP, stivale2_struct) orelse return Error.rsdp;
const rsdp = rsdp_struct.rsdp;
log.debug("RSDP struct: 0x{x}", .{rsdp});
const rsdp_address = kernel.Physical.Address.new(rsdp);
return rsdp_address;
}
pub fn process_smp(stivale2_struct: *Struct) Error![]kernel.arch.CPU {
kernel.assert(@src(), kernel.Virtual.initialized);
const smp_struct = find(stivale.Struct.SMP, stivale2_struct) orelse return Error.smp;
log.debug("SMP struct: {}", .{smp_struct});
const page_count = kernel.bytes_to_pages(smp_struct.cpu_count * @sizeOf(kernel.arch.CPU), false);
const allocation = kernel.Physical.Memory.allocate_pages(page_count) orelse return Error.smp;
const cpus = allocation.access_higher_half([*]kernel.arch.CPU)[0..smp_struct.cpu_count];
const smps = smp_struct.smp_info()[0..smp_struct.cpu_count];
kernel.assert(@src(), smps[0].lapic_id == smp_struct.bsp_lapic_id);
cpus[0].is_bootstrap = true;
for (smps) |smp, cpu_index| {
const cpu = &cpus[cpu_index];
cpu.lapic_id = smp.lapic_id;
}
return cpus;
}
| 47.696296 | 189 | 0.663146 |
89959b7b544f0f08be43e99beb5fd0c8c809c805 | 1,743 | zig | Zig | std/io_test.zig | harryeakins/zig | 8503eff8c12697c35ab5c73d6651c4b996339706 | [
"MIT"
] | null | null | null | std/io_test.zig | harryeakins/zig | 8503eff8c12697c35ab5c73d6651c4b996339706 | [
"MIT"
] | null | null | null | std/io_test.zig | harryeakins/zig | 8503eff8c12697c35ab5c73d6651c4b996339706 | [
"MIT"
] | null | null | null | const std = @import("index.zig");
const io = std.io;
const allocator = std.debug.global_allocator;
const DefaultPrng = std.rand.DefaultPrng;
const assert = std.debug.assert;
const mem = std.mem;
const os = std.os;
const builtin = @import("builtin");
test "write a file, read it, then delete it" {
var data: [1024]u8 = undefined;
var prng = DefaultPrng.init(1234);
prng.random.bytes(data[0..]);
const tmp_file_name = "temp_test_file.txt";
{
var file = try os.File.openWrite(allocator, tmp_file_name);
defer file.close();
var file_out_stream = io.FileOutStream.init(&file);
var buf_stream = io.BufferedOutStream(io.FileOutStream.Error).init(&file_out_stream.stream);
const st = &buf_stream.stream;
try st.print("begin");
try st.write(data[0..]);
try st.print("end");
try buf_stream.flush();
}
{
var file = try os.File.openRead(allocator, tmp_file_name);
defer file.close();
const file_size = try file.getEndPos();
const expected_file_size = "begin".len + data.len + "end".len;
assert(file_size == expected_file_size);
var file_in_stream = io.FileInStream.init(&file);
var buf_stream = io.BufferedInStream(io.FileInStream.Error).init(&file_in_stream.stream);
const st = &buf_stream.stream;
const contents = try st.readAllAlloc(allocator, 2 * 1024);
defer allocator.free(contents);
assert(mem.eql(u8, contents[0.."begin".len], "begin"));
assert(mem.eql(u8, contents["begin".len..contents.len - "end".len], data));
assert(mem.eql(u8, contents[contents.len - "end".len ..], "end"));
}
try os.deleteFile(allocator, tmp_file_name);
}
| 37.085106 | 100 | 0.641997 |
43de39ab119f06ed5e8b13de9d3bf23514a2af88 | 369,811 | zig | Zig | fiat-zig/src/p384_32.zig | eorloff/fiat-crypto | 42515b4b18b653afdeb0cc27b2c5bc0b2686d6ac | [
"BSD-1-Clause",
"Apache-2.0",
"MIT-0",
"MIT"
] | null | null | null | fiat-zig/src/p384_32.zig | eorloff/fiat-crypto | 42515b4b18b653afdeb0cc27b2c5bc0b2686d6ac | [
"BSD-1-Clause",
"Apache-2.0",
"MIT-0",
"MIT"
] | null | null | null | fiat-zig/src/p384_32.zig | eorloff/fiat-crypto | 42515b4b18b653afdeb0cc27b2c5bc0b2686d6ac | [
"BSD-1-Clause",
"Apache-2.0",
"MIT-0",
"MIT"
] | null | null | null | // Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --lang Zig --internal-static --public-function-case camelCase --private-function-case camelCase --public-type-case UpperCamelCase --private-type-case UpperCamelCase --no-prefix-fiat --package-name p384 '' 32 '2^384 - 2^128 - 2^96 + 2^32 - 1' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp
// curve description (via package name): p384
// machine_wordsize = 32 (from "32")
// requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp
// m = 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffeffffffff0000000000000000ffffffff (from "2^384 - 2^128 - 2^96 + 2^32 - 1")
//
// NOTE: In addition to the bounds specified above each function, all
// functions synthesized for this Montgomery arithmetic require the
// input to be strictly less than the prime modulus (m), and also
// require the input to be in the unique saturated representation.
// All functions also ensure that these two properties are true of
// return values.
//
// Computed values:
// eval z = z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) + (z[8] << 256) + (z[9] << 0x120) + (z[10] << 0x140) + (z[11] << 0x160)
// bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) + (z[32] << 256) + (z[33] << 0x108) + (z[34] << 0x110) + (z[35] << 0x118) + (z[36] << 0x120) + (z[37] << 0x128) + (z[38] << 0x130) + (z[39] << 0x138) + (z[40] << 0x140) + (z[41] << 0x148) + (z[42] << 0x150) + (z[43] << 0x158) + (z[44] << 0x160) + (z[45] << 0x168) + (z[46] << 0x170) + (z[47] << 0x178)
// twos_complement_eval z = let x1 := z[0] + (z[1] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) + (z[8] << 256) + (z[9] << 0x120) + (z[10] << 0x140) + (z[11] << 0x160) in
// if x1 & (2^384-1) < 2^383 then x1 & (2^384-1) else (x1 & (2^384-1)) - 2^384
const std = @import("std");
const cast = std.meta.cast;
const mode = std.builtin.mode; // Checked arithmetic is disabled in non-debug modes to avoid side channels
// The type MontgomeryDomainFieldElement is a field element in the Montgomery domain.
// Bounds: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]
pub const MontgomeryDomainFieldElement = [12]u32;
// The type NonMontgomeryDomainFieldElement is a field element NOT in the Montgomery domain.
// Bounds: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]
pub const NonMontgomeryDomainFieldElement = [12]u32;
/// The function addcarryxU32 is an addition with carry.
///
/// Postconditions:
/// out1 = (arg1 + arg2 + arg3) mod 2^32
/// out2 = ⌊(arg1 + arg2 + arg3) / 2^32⌋
///
/// Input Bounds:
/// arg1: [0x0 ~> 0x1]
/// arg2: [0x0 ~> 0xffffffff]
/// arg3: [0x0 ~> 0xffffffff]
/// Output Bounds:
/// out1: [0x0 ~> 0xffffffff]
/// out2: [0x0 ~> 0x1]
inline fn addcarryxU32(out1: *u32, out2: *u1, arg1: u1, arg2: u32, arg3: u32) void {
@setRuntimeSafety(mode == .Debug);
const x1 = ((cast(u64, arg1) + cast(u64, arg2)) + cast(u64, arg3));
const x2 = cast(u32, (x1 & cast(u64, 0xffffffff)));
const x3 = cast(u1, (x1 >> 32));
out1.* = x2;
out2.* = x3;
}
/// The function subborrowxU32 is a subtraction with borrow.
///
/// Postconditions:
/// out1 = (-arg1 + arg2 + -arg3) mod 2^32
/// out2 = -⌊(-arg1 + arg2 + -arg3) / 2^32⌋
///
/// Input Bounds:
/// arg1: [0x0 ~> 0x1]
/// arg2: [0x0 ~> 0xffffffff]
/// arg3: [0x0 ~> 0xffffffff]
/// Output Bounds:
/// out1: [0x0 ~> 0xffffffff]
/// out2: [0x0 ~> 0x1]
inline fn subborrowxU32(out1: *u32, out2: *u1, arg1: u1, arg2: u32, arg3: u32) void {
@setRuntimeSafety(mode == .Debug);
const x1 = ((cast(i64, arg2) - cast(i64, arg1)) - cast(i64, arg3));
const x2 = cast(i1, (x1 >> 32));
const x3 = cast(u32, (x1 & cast(i64, 0xffffffff)));
out1.* = x3;
out2.* = cast(u1, (cast(i2, 0x0) - cast(i2, x2)));
}
/// The function mulxU32 is a multiplication, returning the full double-width result.
///
/// Postconditions:
/// out1 = (arg1 * arg2) mod 2^32
/// out2 = ⌊arg1 * arg2 / 2^32⌋
///
/// Input Bounds:
/// arg1: [0x0 ~> 0xffffffff]
/// arg2: [0x0 ~> 0xffffffff]
/// Output Bounds:
/// out1: [0x0 ~> 0xffffffff]
/// out2: [0x0 ~> 0xffffffff]
inline fn mulxU32(out1: *u32, out2: *u32, arg1: u32, arg2: u32) void {
@setRuntimeSafety(mode == .Debug);
const x1 = (cast(u64, arg1) * cast(u64, arg2));
const x2 = cast(u32, (x1 & cast(u64, 0xffffffff)));
const x3 = cast(u32, (x1 >> 32));
out1.* = x2;
out2.* = x3;
}
/// The function cmovznzU32 is a single-word conditional move.
///
/// Postconditions:
/// out1 = (if arg1 = 0 then arg2 else arg3)
///
/// Input Bounds:
/// arg1: [0x0 ~> 0x1]
/// arg2: [0x0 ~> 0xffffffff]
/// arg3: [0x0 ~> 0xffffffff]
/// Output Bounds:
/// out1: [0x0 ~> 0xffffffff]
inline fn cmovznzU32(out1: *u32, arg1: u1, arg2: u32, arg3: u32) void {
@setRuntimeSafety(mode == .Debug);
const x1 = (~(~arg1));
const x2 = cast(u32, (cast(i64, cast(i1, (cast(i2, 0x0) - cast(i2, x1)))) & cast(i64, 0xffffffff)));
const x3 = ((x2 & arg3) | ((~x2) & arg2));
out1.* = x3;
}
/// The function mul multiplies two field elements in the Montgomery domain.
///
/// Preconditions:
/// 0 ≤ eval arg1 < m
/// 0 ≤ eval arg2 < m
/// Postconditions:
/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg2)) mod m
/// 0 ≤ eval out1 < m
///
pub fn mul(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement, arg2: MontgomeryDomainFieldElement) void {
@setRuntimeSafety(mode == .Debug);
const x1 = (arg1[1]);
const x2 = (arg1[2]);
const x3 = (arg1[3]);
const x4 = (arg1[4]);
const x5 = (arg1[5]);
const x6 = (arg1[6]);
const x7 = (arg1[7]);
const x8 = (arg1[8]);
const x9 = (arg1[9]);
const x10 = (arg1[10]);
const x11 = (arg1[11]);
const x12 = (arg1[0]);
var x13: u32 = undefined;
var x14: u32 = undefined;
mulxU32(&x13, &x14, x12, (arg2[11]));
var x15: u32 = undefined;
var x16: u32 = undefined;
mulxU32(&x15, &x16, x12, (arg2[10]));
var x17: u32 = undefined;
var x18: u32 = undefined;
mulxU32(&x17, &x18, x12, (arg2[9]));
var x19: u32 = undefined;
var x20: u32 = undefined;
mulxU32(&x19, &x20, x12, (arg2[8]));
var x21: u32 = undefined;
var x22: u32 = undefined;
mulxU32(&x21, &x22, x12, (arg2[7]));
var x23: u32 = undefined;
var x24: u32 = undefined;
mulxU32(&x23, &x24, x12, (arg2[6]));
var x25: u32 = undefined;
var x26: u32 = undefined;
mulxU32(&x25, &x26, x12, (arg2[5]));
var x27: u32 = undefined;
var x28: u32 = undefined;
mulxU32(&x27, &x28, x12, (arg2[4]));
var x29: u32 = undefined;
var x30: u32 = undefined;
mulxU32(&x29, &x30, x12, (arg2[3]));
var x31: u32 = undefined;
var x32: u32 = undefined;
mulxU32(&x31, &x32, x12, (arg2[2]));
var x33: u32 = undefined;
var x34: u32 = undefined;
mulxU32(&x33, &x34, x12, (arg2[1]));
var x35: u32 = undefined;
var x36: u32 = undefined;
mulxU32(&x35, &x36, x12, (arg2[0]));
var x37: u32 = undefined;
var x38: u1 = undefined;
addcarryxU32(&x37, &x38, 0x0, x36, x33);
var x39: u32 = undefined;
var x40: u1 = undefined;
addcarryxU32(&x39, &x40, x38, x34, x31);
var x41: u32 = undefined;
var x42: u1 = undefined;
addcarryxU32(&x41, &x42, x40, x32, x29);
var x43: u32 = undefined;
var x44: u1 = undefined;
addcarryxU32(&x43, &x44, x42, x30, x27);
var x45: u32 = undefined;
var x46: u1 = undefined;
addcarryxU32(&x45, &x46, x44, x28, x25);
var x47: u32 = undefined;
var x48: u1 = undefined;
addcarryxU32(&x47, &x48, x46, x26, x23);
var x49: u32 = undefined;
var x50: u1 = undefined;
addcarryxU32(&x49, &x50, x48, x24, x21);
var x51: u32 = undefined;
var x52: u1 = undefined;
addcarryxU32(&x51, &x52, x50, x22, x19);
var x53: u32 = undefined;
var x54: u1 = undefined;
addcarryxU32(&x53, &x54, x52, x20, x17);
var x55: u32 = undefined;
var x56: u1 = undefined;
addcarryxU32(&x55, &x56, x54, x18, x15);
var x57: u32 = undefined;
var x58: u1 = undefined;
addcarryxU32(&x57, &x58, x56, x16, x13);
const x59 = (cast(u32, x58) + x14);
var x60: u32 = undefined;
var x61: u32 = undefined;
mulxU32(&x60, &x61, x35, 0xffffffff);
var x62: u32 = undefined;
var x63: u32 = undefined;
mulxU32(&x62, &x63, x35, 0xffffffff);
var x64: u32 = undefined;
var x65: u32 = undefined;
mulxU32(&x64, &x65, x35, 0xffffffff);
var x66: u32 = undefined;
var x67: u32 = undefined;
mulxU32(&x66, &x67, x35, 0xffffffff);
var x68: u32 = undefined;
var x69: u32 = undefined;
mulxU32(&x68, &x69, x35, 0xffffffff);
var x70: u32 = undefined;
var x71: u32 = undefined;
mulxU32(&x70, &x71, x35, 0xffffffff);
var x72: u32 = undefined;
var x73: u32 = undefined;
mulxU32(&x72, &x73, x35, 0xffffffff);
var x74: u32 = undefined;
var x75: u32 = undefined;
mulxU32(&x74, &x75, x35, 0xfffffffe);
var x76: u32 = undefined;
var x77: u32 = undefined;
mulxU32(&x76, &x77, x35, 0xffffffff);
var x78: u32 = undefined;
var x79: u32 = undefined;
mulxU32(&x78, &x79, x35, 0xffffffff);
var x80: u32 = undefined;
var x81: u1 = undefined;
addcarryxU32(&x80, &x81, 0x0, x77, x74);
var x82: u32 = undefined;
var x83: u1 = undefined;
addcarryxU32(&x82, &x83, x81, x75, x72);
var x84: u32 = undefined;
var x85: u1 = undefined;
addcarryxU32(&x84, &x85, x83, x73, x70);
var x86: u32 = undefined;
var x87: u1 = undefined;
addcarryxU32(&x86, &x87, x85, x71, x68);
var x88: u32 = undefined;
var x89: u1 = undefined;
addcarryxU32(&x88, &x89, x87, x69, x66);
var x90: u32 = undefined;
var x91: u1 = undefined;
addcarryxU32(&x90, &x91, x89, x67, x64);
var x92: u32 = undefined;
var x93: u1 = undefined;
addcarryxU32(&x92, &x93, x91, x65, x62);
var x94: u32 = undefined;
var x95: u1 = undefined;
addcarryxU32(&x94, &x95, x93, x63, x60);
const x96 = (cast(u32, x95) + x61);
var x97: u32 = undefined;
var x98: u1 = undefined;
addcarryxU32(&x97, &x98, 0x0, x35, x78);
var x99: u32 = undefined;
var x100: u1 = undefined;
addcarryxU32(&x99, &x100, x98, x37, x79);
var x101: u32 = undefined;
var x102: u1 = undefined;
addcarryxU32(&x101, &x102, x100, x39, cast(u32, 0x0));
var x103: u32 = undefined;
var x104: u1 = undefined;
addcarryxU32(&x103, &x104, x102, x41, x76);
var x105: u32 = undefined;
var x106: u1 = undefined;
addcarryxU32(&x105, &x106, x104, x43, x80);
var x107: u32 = undefined;
var x108: u1 = undefined;
addcarryxU32(&x107, &x108, x106, x45, x82);
var x109: u32 = undefined;
var x110: u1 = undefined;
addcarryxU32(&x109, &x110, x108, x47, x84);
var x111: u32 = undefined;
var x112: u1 = undefined;
addcarryxU32(&x111, &x112, x110, x49, x86);
var x113: u32 = undefined;
var x114: u1 = undefined;
addcarryxU32(&x113, &x114, x112, x51, x88);
var x115: u32 = undefined;
var x116: u1 = undefined;
addcarryxU32(&x115, &x116, x114, x53, x90);
var x117: u32 = undefined;
var x118: u1 = undefined;
addcarryxU32(&x117, &x118, x116, x55, x92);
var x119: u32 = undefined;
var x120: u1 = undefined;
addcarryxU32(&x119, &x120, x118, x57, x94);
var x121: u32 = undefined;
var x122: u1 = undefined;
addcarryxU32(&x121, &x122, x120, x59, x96);
var x123: u32 = undefined;
var x124: u32 = undefined;
mulxU32(&x123, &x124, x1, (arg2[11]));
var x125: u32 = undefined;
var x126: u32 = undefined;
mulxU32(&x125, &x126, x1, (arg2[10]));
var x127: u32 = undefined;
var x128: u32 = undefined;
mulxU32(&x127, &x128, x1, (arg2[9]));
var x129: u32 = undefined;
var x130: u32 = undefined;
mulxU32(&x129, &x130, x1, (arg2[8]));
var x131: u32 = undefined;
var x132: u32 = undefined;
mulxU32(&x131, &x132, x1, (arg2[7]));
var x133: u32 = undefined;
var x134: u32 = undefined;
mulxU32(&x133, &x134, x1, (arg2[6]));
var x135: u32 = undefined;
var x136: u32 = undefined;
mulxU32(&x135, &x136, x1, (arg2[5]));
var x137: u32 = undefined;
var x138: u32 = undefined;
mulxU32(&x137, &x138, x1, (arg2[4]));
var x139: u32 = undefined;
var x140: u32 = undefined;
mulxU32(&x139, &x140, x1, (arg2[3]));
var x141: u32 = undefined;
var x142: u32 = undefined;
mulxU32(&x141, &x142, x1, (arg2[2]));
var x143: u32 = undefined;
var x144: u32 = undefined;
mulxU32(&x143, &x144, x1, (arg2[1]));
var x145: u32 = undefined;
var x146: u32 = undefined;
mulxU32(&x145, &x146, x1, (arg2[0]));
var x147: u32 = undefined;
var x148: u1 = undefined;
addcarryxU32(&x147, &x148, 0x0, x146, x143);
var x149: u32 = undefined;
var x150: u1 = undefined;
addcarryxU32(&x149, &x150, x148, x144, x141);
var x151: u32 = undefined;
var x152: u1 = undefined;
addcarryxU32(&x151, &x152, x150, x142, x139);
var x153: u32 = undefined;
var x154: u1 = undefined;
addcarryxU32(&x153, &x154, x152, x140, x137);
var x155: u32 = undefined;
var x156: u1 = undefined;
addcarryxU32(&x155, &x156, x154, x138, x135);
var x157: u32 = undefined;
var x158: u1 = undefined;
addcarryxU32(&x157, &x158, x156, x136, x133);
var x159: u32 = undefined;
var x160: u1 = undefined;
addcarryxU32(&x159, &x160, x158, x134, x131);
var x161: u32 = undefined;
var x162: u1 = undefined;
addcarryxU32(&x161, &x162, x160, x132, x129);
var x163: u32 = undefined;
var x164: u1 = undefined;
addcarryxU32(&x163, &x164, x162, x130, x127);
var x165: u32 = undefined;
var x166: u1 = undefined;
addcarryxU32(&x165, &x166, x164, x128, x125);
var x167: u32 = undefined;
var x168: u1 = undefined;
addcarryxU32(&x167, &x168, x166, x126, x123);
const x169 = (cast(u32, x168) + x124);
var x170: u32 = undefined;
var x171: u1 = undefined;
addcarryxU32(&x170, &x171, 0x0, x99, x145);
var x172: u32 = undefined;
var x173: u1 = undefined;
addcarryxU32(&x172, &x173, x171, x101, x147);
var x174: u32 = undefined;
var x175: u1 = undefined;
addcarryxU32(&x174, &x175, x173, x103, x149);
var x176: u32 = undefined;
var x177: u1 = undefined;
addcarryxU32(&x176, &x177, x175, x105, x151);
var x178: u32 = undefined;
var x179: u1 = undefined;
addcarryxU32(&x178, &x179, x177, x107, x153);
var x180: u32 = undefined;
var x181: u1 = undefined;
addcarryxU32(&x180, &x181, x179, x109, x155);
var x182: u32 = undefined;
var x183: u1 = undefined;
addcarryxU32(&x182, &x183, x181, x111, x157);
var x184: u32 = undefined;
var x185: u1 = undefined;
addcarryxU32(&x184, &x185, x183, x113, x159);
var x186: u32 = undefined;
var x187: u1 = undefined;
addcarryxU32(&x186, &x187, x185, x115, x161);
var x188: u32 = undefined;
var x189: u1 = undefined;
addcarryxU32(&x188, &x189, x187, x117, x163);
var x190: u32 = undefined;
var x191: u1 = undefined;
addcarryxU32(&x190, &x191, x189, x119, x165);
var x192: u32 = undefined;
var x193: u1 = undefined;
addcarryxU32(&x192, &x193, x191, x121, x167);
var x194: u32 = undefined;
var x195: u1 = undefined;
addcarryxU32(&x194, &x195, x193, cast(u32, x122), x169);
var x196: u32 = undefined;
var x197: u32 = undefined;
mulxU32(&x196, &x197, x170, 0xffffffff);
var x198: u32 = undefined;
var x199: u32 = undefined;
mulxU32(&x198, &x199, x170, 0xffffffff);
var x200: u32 = undefined;
var x201: u32 = undefined;
mulxU32(&x200, &x201, x170, 0xffffffff);
var x202: u32 = undefined;
var x203: u32 = undefined;
mulxU32(&x202, &x203, x170, 0xffffffff);
var x204: u32 = undefined;
var x205: u32 = undefined;
mulxU32(&x204, &x205, x170, 0xffffffff);
var x206: u32 = undefined;
var x207: u32 = undefined;
mulxU32(&x206, &x207, x170, 0xffffffff);
var x208: u32 = undefined;
var x209: u32 = undefined;
mulxU32(&x208, &x209, x170, 0xffffffff);
var x210: u32 = undefined;
var x211: u32 = undefined;
mulxU32(&x210, &x211, x170, 0xfffffffe);
var x212: u32 = undefined;
var x213: u32 = undefined;
mulxU32(&x212, &x213, x170, 0xffffffff);
var x214: u32 = undefined;
var x215: u32 = undefined;
mulxU32(&x214, &x215, x170, 0xffffffff);
var x216: u32 = undefined;
var x217: u1 = undefined;
addcarryxU32(&x216, &x217, 0x0, x213, x210);
var x218: u32 = undefined;
var x219: u1 = undefined;
addcarryxU32(&x218, &x219, x217, x211, x208);
var x220: u32 = undefined;
var x221: u1 = undefined;
addcarryxU32(&x220, &x221, x219, x209, x206);
var x222: u32 = undefined;
var x223: u1 = undefined;
addcarryxU32(&x222, &x223, x221, x207, x204);
var x224: u32 = undefined;
var x225: u1 = undefined;
addcarryxU32(&x224, &x225, x223, x205, x202);
var x226: u32 = undefined;
var x227: u1 = undefined;
addcarryxU32(&x226, &x227, x225, x203, x200);
var x228: u32 = undefined;
var x229: u1 = undefined;
addcarryxU32(&x228, &x229, x227, x201, x198);
var x230: u32 = undefined;
var x231: u1 = undefined;
addcarryxU32(&x230, &x231, x229, x199, x196);
const x232 = (cast(u32, x231) + x197);
var x233: u32 = undefined;
var x234: u1 = undefined;
addcarryxU32(&x233, &x234, 0x0, x170, x214);
var x235: u32 = undefined;
var x236: u1 = undefined;
addcarryxU32(&x235, &x236, x234, x172, x215);
var x237: u32 = undefined;
var x238: u1 = undefined;
addcarryxU32(&x237, &x238, x236, x174, cast(u32, 0x0));
var x239: u32 = undefined;
var x240: u1 = undefined;
addcarryxU32(&x239, &x240, x238, x176, x212);
var x241: u32 = undefined;
var x242: u1 = undefined;
addcarryxU32(&x241, &x242, x240, x178, x216);
var x243: u32 = undefined;
var x244: u1 = undefined;
addcarryxU32(&x243, &x244, x242, x180, x218);
var x245: u32 = undefined;
var x246: u1 = undefined;
addcarryxU32(&x245, &x246, x244, x182, x220);
var x247: u32 = undefined;
var x248: u1 = undefined;
addcarryxU32(&x247, &x248, x246, x184, x222);
var x249: u32 = undefined;
var x250: u1 = undefined;
addcarryxU32(&x249, &x250, x248, x186, x224);
var x251: u32 = undefined;
var x252: u1 = undefined;
addcarryxU32(&x251, &x252, x250, x188, x226);
var x253: u32 = undefined;
var x254: u1 = undefined;
addcarryxU32(&x253, &x254, x252, x190, x228);
var x255: u32 = undefined;
var x256: u1 = undefined;
addcarryxU32(&x255, &x256, x254, x192, x230);
var x257: u32 = undefined;
var x258: u1 = undefined;
addcarryxU32(&x257, &x258, x256, x194, x232);
const x259 = (cast(u32, x258) + cast(u32, x195));
var x260: u32 = undefined;
var x261: u32 = undefined;
mulxU32(&x260, &x261, x2, (arg2[11]));
var x262: u32 = undefined;
var x263: u32 = undefined;
mulxU32(&x262, &x263, x2, (arg2[10]));
var x264: u32 = undefined;
var x265: u32 = undefined;
mulxU32(&x264, &x265, x2, (arg2[9]));
var x266: u32 = undefined;
var x267: u32 = undefined;
mulxU32(&x266, &x267, x2, (arg2[8]));
var x268: u32 = undefined;
var x269: u32 = undefined;
mulxU32(&x268, &x269, x2, (arg2[7]));
var x270: u32 = undefined;
var x271: u32 = undefined;
mulxU32(&x270, &x271, x2, (arg2[6]));
var x272: u32 = undefined;
var x273: u32 = undefined;
mulxU32(&x272, &x273, x2, (arg2[5]));
var x274: u32 = undefined;
var x275: u32 = undefined;
mulxU32(&x274, &x275, x2, (arg2[4]));
var x276: u32 = undefined;
var x277: u32 = undefined;
mulxU32(&x276, &x277, x2, (arg2[3]));
var x278: u32 = undefined;
var x279: u32 = undefined;
mulxU32(&x278, &x279, x2, (arg2[2]));
var x280: u32 = undefined;
var x281: u32 = undefined;
mulxU32(&x280, &x281, x2, (arg2[1]));
var x282: u32 = undefined;
var x283: u32 = undefined;
mulxU32(&x282, &x283, x2, (arg2[0]));
var x284: u32 = undefined;
var x285: u1 = undefined;
addcarryxU32(&x284, &x285, 0x0, x283, x280);
var x286: u32 = undefined;
var x287: u1 = undefined;
addcarryxU32(&x286, &x287, x285, x281, x278);
var x288: u32 = undefined;
var x289: u1 = undefined;
addcarryxU32(&x288, &x289, x287, x279, x276);
var x290: u32 = undefined;
var x291: u1 = undefined;
addcarryxU32(&x290, &x291, x289, x277, x274);
var x292: u32 = undefined;
var x293: u1 = undefined;
addcarryxU32(&x292, &x293, x291, x275, x272);
var x294: u32 = undefined;
var x295: u1 = undefined;
addcarryxU32(&x294, &x295, x293, x273, x270);
var x296: u32 = undefined;
var x297: u1 = undefined;
addcarryxU32(&x296, &x297, x295, x271, x268);
var x298: u32 = undefined;
var x299: u1 = undefined;
addcarryxU32(&x298, &x299, x297, x269, x266);
var x300: u32 = undefined;
var x301: u1 = undefined;
addcarryxU32(&x300, &x301, x299, x267, x264);
var x302: u32 = undefined;
var x303: u1 = undefined;
addcarryxU32(&x302, &x303, x301, x265, x262);
var x304: u32 = undefined;
var x305: u1 = undefined;
addcarryxU32(&x304, &x305, x303, x263, x260);
const x306 = (cast(u32, x305) + x261);
var x307: u32 = undefined;
var x308: u1 = undefined;
addcarryxU32(&x307, &x308, 0x0, x235, x282);
var x309: u32 = undefined;
var x310: u1 = undefined;
addcarryxU32(&x309, &x310, x308, x237, x284);
var x311: u32 = undefined;
var x312: u1 = undefined;
addcarryxU32(&x311, &x312, x310, x239, x286);
var x313: u32 = undefined;
var x314: u1 = undefined;
addcarryxU32(&x313, &x314, x312, x241, x288);
var x315: u32 = undefined;
var x316: u1 = undefined;
addcarryxU32(&x315, &x316, x314, x243, x290);
var x317: u32 = undefined;
var x318: u1 = undefined;
addcarryxU32(&x317, &x318, x316, x245, x292);
var x319: u32 = undefined;
var x320: u1 = undefined;
addcarryxU32(&x319, &x320, x318, x247, x294);
var x321: u32 = undefined;
var x322: u1 = undefined;
addcarryxU32(&x321, &x322, x320, x249, x296);
var x323: u32 = undefined;
var x324: u1 = undefined;
addcarryxU32(&x323, &x324, x322, x251, x298);
var x325: u32 = undefined;
var x326: u1 = undefined;
addcarryxU32(&x325, &x326, x324, x253, x300);
var x327: u32 = undefined;
var x328: u1 = undefined;
addcarryxU32(&x327, &x328, x326, x255, x302);
var x329: u32 = undefined;
var x330: u1 = undefined;
addcarryxU32(&x329, &x330, x328, x257, x304);
var x331: u32 = undefined;
var x332: u1 = undefined;
addcarryxU32(&x331, &x332, x330, x259, x306);
var x333: u32 = undefined;
var x334: u32 = undefined;
mulxU32(&x333, &x334, x307, 0xffffffff);
var x335: u32 = undefined;
var x336: u32 = undefined;
mulxU32(&x335, &x336, x307, 0xffffffff);
var x337: u32 = undefined;
var x338: u32 = undefined;
mulxU32(&x337, &x338, x307, 0xffffffff);
var x339: u32 = undefined;
var x340: u32 = undefined;
mulxU32(&x339, &x340, x307, 0xffffffff);
var x341: u32 = undefined;
var x342: u32 = undefined;
mulxU32(&x341, &x342, x307, 0xffffffff);
var x343: u32 = undefined;
var x344: u32 = undefined;
mulxU32(&x343, &x344, x307, 0xffffffff);
var x345: u32 = undefined;
var x346: u32 = undefined;
mulxU32(&x345, &x346, x307, 0xffffffff);
var x347: u32 = undefined;
var x348: u32 = undefined;
mulxU32(&x347, &x348, x307, 0xfffffffe);
var x349: u32 = undefined;
var x350: u32 = undefined;
mulxU32(&x349, &x350, x307, 0xffffffff);
var x351: u32 = undefined;
var x352: u32 = undefined;
mulxU32(&x351, &x352, x307, 0xffffffff);
var x353: u32 = undefined;
var x354: u1 = undefined;
addcarryxU32(&x353, &x354, 0x0, x350, x347);
var x355: u32 = undefined;
var x356: u1 = undefined;
addcarryxU32(&x355, &x356, x354, x348, x345);
var x357: u32 = undefined;
var x358: u1 = undefined;
addcarryxU32(&x357, &x358, x356, x346, x343);
var x359: u32 = undefined;
var x360: u1 = undefined;
addcarryxU32(&x359, &x360, x358, x344, x341);
var x361: u32 = undefined;
var x362: u1 = undefined;
addcarryxU32(&x361, &x362, x360, x342, x339);
var x363: u32 = undefined;
var x364: u1 = undefined;
addcarryxU32(&x363, &x364, x362, x340, x337);
var x365: u32 = undefined;
var x366: u1 = undefined;
addcarryxU32(&x365, &x366, x364, x338, x335);
var x367: u32 = undefined;
var x368: u1 = undefined;
addcarryxU32(&x367, &x368, x366, x336, x333);
const x369 = (cast(u32, x368) + x334);
var x370: u32 = undefined;
var x371: u1 = undefined;
addcarryxU32(&x370, &x371, 0x0, x307, x351);
var x372: u32 = undefined;
var x373: u1 = undefined;
addcarryxU32(&x372, &x373, x371, x309, x352);
var x374: u32 = undefined;
var x375: u1 = undefined;
addcarryxU32(&x374, &x375, x373, x311, cast(u32, 0x0));
var x376: u32 = undefined;
var x377: u1 = undefined;
addcarryxU32(&x376, &x377, x375, x313, x349);
var x378: u32 = undefined;
var x379: u1 = undefined;
addcarryxU32(&x378, &x379, x377, x315, x353);
var x380: u32 = undefined;
var x381: u1 = undefined;
addcarryxU32(&x380, &x381, x379, x317, x355);
var x382: u32 = undefined;
var x383: u1 = undefined;
addcarryxU32(&x382, &x383, x381, x319, x357);
var x384: u32 = undefined;
var x385: u1 = undefined;
addcarryxU32(&x384, &x385, x383, x321, x359);
var x386: u32 = undefined;
var x387: u1 = undefined;
addcarryxU32(&x386, &x387, x385, x323, x361);
var x388: u32 = undefined;
var x389: u1 = undefined;
addcarryxU32(&x388, &x389, x387, x325, x363);
var x390: u32 = undefined;
var x391: u1 = undefined;
addcarryxU32(&x390, &x391, x389, x327, x365);
var x392: u32 = undefined;
var x393: u1 = undefined;
addcarryxU32(&x392, &x393, x391, x329, x367);
var x394: u32 = undefined;
var x395: u1 = undefined;
addcarryxU32(&x394, &x395, x393, x331, x369);
const x396 = (cast(u32, x395) + cast(u32, x332));
var x397: u32 = undefined;
var x398: u32 = undefined;
mulxU32(&x397, &x398, x3, (arg2[11]));
var x399: u32 = undefined;
var x400: u32 = undefined;
mulxU32(&x399, &x400, x3, (arg2[10]));
var x401: u32 = undefined;
var x402: u32 = undefined;
mulxU32(&x401, &x402, x3, (arg2[9]));
var x403: u32 = undefined;
var x404: u32 = undefined;
mulxU32(&x403, &x404, x3, (arg2[8]));
var x405: u32 = undefined;
var x406: u32 = undefined;
mulxU32(&x405, &x406, x3, (arg2[7]));
var x407: u32 = undefined;
var x408: u32 = undefined;
mulxU32(&x407, &x408, x3, (arg2[6]));
var x409: u32 = undefined;
var x410: u32 = undefined;
mulxU32(&x409, &x410, x3, (arg2[5]));
var x411: u32 = undefined;
var x412: u32 = undefined;
mulxU32(&x411, &x412, x3, (arg2[4]));
var x413: u32 = undefined;
var x414: u32 = undefined;
mulxU32(&x413, &x414, x3, (arg2[3]));
var x415: u32 = undefined;
var x416: u32 = undefined;
mulxU32(&x415, &x416, x3, (arg2[2]));
var x417: u32 = undefined;
var x418: u32 = undefined;
mulxU32(&x417, &x418, x3, (arg2[1]));
var x419: u32 = undefined;
var x420: u32 = undefined;
mulxU32(&x419, &x420, x3, (arg2[0]));
var x421: u32 = undefined;
var x422: u1 = undefined;
addcarryxU32(&x421, &x422, 0x0, x420, x417);
var x423: u32 = undefined;
var x424: u1 = undefined;
addcarryxU32(&x423, &x424, x422, x418, x415);
var x425: u32 = undefined;
var x426: u1 = undefined;
addcarryxU32(&x425, &x426, x424, x416, x413);
var x427: u32 = undefined;
var x428: u1 = undefined;
addcarryxU32(&x427, &x428, x426, x414, x411);
var x429: u32 = undefined;
var x430: u1 = undefined;
addcarryxU32(&x429, &x430, x428, x412, x409);
var x431: u32 = undefined;
var x432: u1 = undefined;
addcarryxU32(&x431, &x432, x430, x410, x407);
var x433: u32 = undefined;
var x434: u1 = undefined;
addcarryxU32(&x433, &x434, x432, x408, x405);
var x435: u32 = undefined;
var x436: u1 = undefined;
addcarryxU32(&x435, &x436, x434, x406, x403);
var x437: u32 = undefined;
var x438: u1 = undefined;
addcarryxU32(&x437, &x438, x436, x404, x401);
var x439: u32 = undefined;
var x440: u1 = undefined;
addcarryxU32(&x439, &x440, x438, x402, x399);
var x441: u32 = undefined;
var x442: u1 = undefined;
addcarryxU32(&x441, &x442, x440, x400, x397);
const x443 = (cast(u32, x442) + x398);
var x444: u32 = undefined;
var x445: u1 = undefined;
addcarryxU32(&x444, &x445, 0x0, x372, x419);
var x446: u32 = undefined;
var x447: u1 = undefined;
addcarryxU32(&x446, &x447, x445, x374, x421);
var x448: u32 = undefined;
var x449: u1 = undefined;
addcarryxU32(&x448, &x449, x447, x376, x423);
var x450: u32 = undefined;
var x451: u1 = undefined;
addcarryxU32(&x450, &x451, x449, x378, x425);
var x452: u32 = undefined;
var x453: u1 = undefined;
addcarryxU32(&x452, &x453, x451, x380, x427);
var x454: u32 = undefined;
var x455: u1 = undefined;
addcarryxU32(&x454, &x455, x453, x382, x429);
var x456: u32 = undefined;
var x457: u1 = undefined;
addcarryxU32(&x456, &x457, x455, x384, x431);
var x458: u32 = undefined;
var x459: u1 = undefined;
addcarryxU32(&x458, &x459, x457, x386, x433);
var x460: u32 = undefined;
var x461: u1 = undefined;
addcarryxU32(&x460, &x461, x459, x388, x435);
var x462: u32 = undefined;
var x463: u1 = undefined;
addcarryxU32(&x462, &x463, x461, x390, x437);
var x464: u32 = undefined;
var x465: u1 = undefined;
addcarryxU32(&x464, &x465, x463, x392, x439);
var x466: u32 = undefined;
var x467: u1 = undefined;
addcarryxU32(&x466, &x467, x465, x394, x441);
var x468: u32 = undefined;
var x469: u1 = undefined;
addcarryxU32(&x468, &x469, x467, x396, x443);
var x470: u32 = undefined;
var x471: u32 = undefined;
mulxU32(&x470, &x471, x444, 0xffffffff);
var x472: u32 = undefined;
var x473: u32 = undefined;
mulxU32(&x472, &x473, x444, 0xffffffff);
var x474: u32 = undefined;
var x475: u32 = undefined;
mulxU32(&x474, &x475, x444, 0xffffffff);
var x476: u32 = undefined;
var x477: u32 = undefined;
mulxU32(&x476, &x477, x444, 0xffffffff);
var x478: u32 = undefined;
var x479: u32 = undefined;
mulxU32(&x478, &x479, x444, 0xffffffff);
var x480: u32 = undefined;
var x481: u32 = undefined;
mulxU32(&x480, &x481, x444, 0xffffffff);
var x482: u32 = undefined;
var x483: u32 = undefined;
mulxU32(&x482, &x483, x444, 0xffffffff);
var x484: u32 = undefined;
var x485: u32 = undefined;
mulxU32(&x484, &x485, x444, 0xfffffffe);
var x486: u32 = undefined;
var x487: u32 = undefined;
mulxU32(&x486, &x487, x444, 0xffffffff);
var x488: u32 = undefined;
var x489: u32 = undefined;
mulxU32(&x488, &x489, x444, 0xffffffff);
var x490: u32 = undefined;
var x491: u1 = undefined;
addcarryxU32(&x490, &x491, 0x0, x487, x484);
var x492: u32 = undefined;
var x493: u1 = undefined;
addcarryxU32(&x492, &x493, x491, x485, x482);
var x494: u32 = undefined;
var x495: u1 = undefined;
addcarryxU32(&x494, &x495, x493, x483, x480);
var x496: u32 = undefined;
var x497: u1 = undefined;
addcarryxU32(&x496, &x497, x495, x481, x478);
var x498: u32 = undefined;
var x499: u1 = undefined;
addcarryxU32(&x498, &x499, x497, x479, x476);
var x500: u32 = undefined;
var x501: u1 = undefined;
addcarryxU32(&x500, &x501, x499, x477, x474);
var x502: u32 = undefined;
var x503: u1 = undefined;
addcarryxU32(&x502, &x503, x501, x475, x472);
var x504: u32 = undefined;
var x505: u1 = undefined;
addcarryxU32(&x504, &x505, x503, x473, x470);
const x506 = (cast(u32, x505) + x471);
var x507: u32 = undefined;
var x508: u1 = undefined;
addcarryxU32(&x507, &x508, 0x0, x444, x488);
var x509: u32 = undefined;
var x510: u1 = undefined;
addcarryxU32(&x509, &x510, x508, x446, x489);
var x511: u32 = undefined;
var x512: u1 = undefined;
addcarryxU32(&x511, &x512, x510, x448, cast(u32, 0x0));
var x513: u32 = undefined;
var x514: u1 = undefined;
addcarryxU32(&x513, &x514, x512, x450, x486);
var x515: u32 = undefined;
var x516: u1 = undefined;
addcarryxU32(&x515, &x516, x514, x452, x490);
var x517: u32 = undefined;
var x518: u1 = undefined;
addcarryxU32(&x517, &x518, x516, x454, x492);
var x519: u32 = undefined;
var x520: u1 = undefined;
addcarryxU32(&x519, &x520, x518, x456, x494);
var x521: u32 = undefined;
var x522: u1 = undefined;
addcarryxU32(&x521, &x522, x520, x458, x496);
var x523: u32 = undefined;
var x524: u1 = undefined;
addcarryxU32(&x523, &x524, x522, x460, x498);
var x525: u32 = undefined;
var x526: u1 = undefined;
addcarryxU32(&x525, &x526, x524, x462, x500);
var x527: u32 = undefined;
var x528: u1 = undefined;
addcarryxU32(&x527, &x528, x526, x464, x502);
var x529: u32 = undefined;
var x530: u1 = undefined;
addcarryxU32(&x529, &x530, x528, x466, x504);
var x531: u32 = undefined;
var x532: u1 = undefined;
addcarryxU32(&x531, &x532, x530, x468, x506);
const x533 = (cast(u32, x532) + cast(u32, x469));
var x534: u32 = undefined;
var x535: u32 = undefined;
mulxU32(&x534, &x535, x4, (arg2[11]));
var x536: u32 = undefined;
var x537: u32 = undefined;
mulxU32(&x536, &x537, x4, (arg2[10]));
var x538: u32 = undefined;
var x539: u32 = undefined;
mulxU32(&x538, &x539, x4, (arg2[9]));
var x540: u32 = undefined;
var x541: u32 = undefined;
mulxU32(&x540, &x541, x4, (arg2[8]));
var x542: u32 = undefined;
var x543: u32 = undefined;
mulxU32(&x542, &x543, x4, (arg2[7]));
var x544: u32 = undefined;
var x545: u32 = undefined;
mulxU32(&x544, &x545, x4, (arg2[6]));
var x546: u32 = undefined;
var x547: u32 = undefined;
mulxU32(&x546, &x547, x4, (arg2[5]));
var x548: u32 = undefined;
var x549: u32 = undefined;
mulxU32(&x548, &x549, x4, (arg2[4]));
var x550: u32 = undefined;
var x551: u32 = undefined;
mulxU32(&x550, &x551, x4, (arg2[3]));
var x552: u32 = undefined;
var x553: u32 = undefined;
mulxU32(&x552, &x553, x4, (arg2[2]));
var x554: u32 = undefined;
var x555: u32 = undefined;
mulxU32(&x554, &x555, x4, (arg2[1]));
var x556: u32 = undefined;
var x557: u32 = undefined;
mulxU32(&x556, &x557, x4, (arg2[0]));
var x558: u32 = undefined;
var x559: u1 = undefined;
addcarryxU32(&x558, &x559, 0x0, x557, x554);
var x560: u32 = undefined;
var x561: u1 = undefined;
addcarryxU32(&x560, &x561, x559, x555, x552);
var x562: u32 = undefined;
var x563: u1 = undefined;
addcarryxU32(&x562, &x563, x561, x553, x550);
var x564: u32 = undefined;
var x565: u1 = undefined;
addcarryxU32(&x564, &x565, x563, x551, x548);
var x566: u32 = undefined;
var x567: u1 = undefined;
addcarryxU32(&x566, &x567, x565, x549, x546);
var x568: u32 = undefined;
var x569: u1 = undefined;
addcarryxU32(&x568, &x569, x567, x547, x544);
var x570: u32 = undefined;
var x571: u1 = undefined;
addcarryxU32(&x570, &x571, x569, x545, x542);
var x572: u32 = undefined;
var x573: u1 = undefined;
addcarryxU32(&x572, &x573, x571, x543, x540);
var x574: u32 = undefined;
var x575: u1 = undefined;
addcarryxU32(&x574, &x575, x573, x541, x538);
var x576: u32 = undefined;
var x577: u1 = undefined;
addcarryxU32(&x576, &x577, x575, x539, x536);
var x578: u32 = undefined;
var x579: u1 = undefined;
addcarryxU32(&x578, &x579, x577, x537, x534);
const x580 = (cast(u32, x579) + x535);
var x581: u32 = undefined;
var x582: u1 = undefined;
addcarryxU32(&x581, &x582, 0x0, x509, x556);
var x583: u32 = undefined;
var x584: u1 = undefined;
addcarryxU32(&x583, &x584, x582, x511, x558);
var x585: u32 = undefined;
var x586: u1 = undefined;
addcarryxU32(&x585, &x586, x584, x513, x560);
var x587: u32 = undefined;
var x588: u1 = undefined;
addcarryxU32(&x587, &x588, x586, x515, x562);
var x589: u32 = undefined;
var x590: u1 = undefined;
addcarryxU32(&x589, &x590, x588, x517, x564);
var x591: u32 = undefined;
var x592: u1 = undefined;
addcarryxU32(&x591, &x592, x590, x519, x566);
var x593: u32 = undefined;
var x594: u1 = undefined;
addcarryxU32(&x593, &x594, x592, x521, x568);
var x595: u32 = undefined;
var x596: u1 = undefined;
addcarryxU32(&x595, &x596, x594, x523, x570);
var x597: u32 = undefined;
var x598: u1 = undefined;
addcarryxU32(&x597, &x598, x596, x525, x572);
var x599: u32 = undefined;
var x600: u1 = undefined;
addcarryxU32(&x599, &x600, x598, x527, x574);
var x601: u32 = undefined;
var x602: u1 = undefined;
addcarryxU32(&x601, &x602, x600, x529, x576);
var x603: u32 = undefined;
var x604: u1 = undefined;
addcarryxU32(&x603, &x604, x602, x531, x578);
var x605: u32 = undefined;
var x606: u1 = undefined;
addcarryxU32(&x605, &x606, x604, x533, x580);
var x607: u32 = undefined;
var x608: u32 = undefined;
mulxU32(&x607, &x608, x581, 0xffffffff);
var x609: u32 = undefined;
var x610: u32 = undefined;
mulxU32(&x609, &x610, x581, 0xffffffff);
var x611: u32 = undefined;
var x612: u32 = undefined;
mulxU32(&x611, &x612, x581, 0xffffffff);
var x613: u32 = undefined;
var x614: u32 = undefined;
mulxU32(&x613, &x614, x581, 0xffffffff);
var x615: u32 = undefined;
var x616: u32 = undefined;
mulxU32(&x615, &x616, x581, 0xffffffff);
var x617: u32 = undefined;
var x618: u32 = undefined;
mulxU32(&x617, &x618, x581, 0xffffffff);
var x619: u32 = undefined;
var x620: u32 = undefined;
mulxU32(&x619, &x620, x581, 0xffffffff);
var x621: u32 = undefined;
var x622: u32 = undefined;
mulxU32(&x621, &x622, x581, 0xfffffffe);
var x623: u32 = undefined;
var x624: u32 = undefined;
mulxU32(&x623, &x624, x581, 0xffffffff);
var x625: u32 = undefined;
var x626: u32 = undefined;
mulxU32(&x625, &x626, x581, 0xffffffff);
var x627: u32 = undefined;
var x628: u1 = undefined;
addcarryxU32(&x627, &x628, 0x0, x624, x621);
var x629: u32 = undefined;
var x630: u1 = undefined;
addcarryxU32(&x629, &x630, x628, x622, x619);
var x631: u32 = undefined;
var x632: u1 = undefined;
addcarryxU32(&x631, &x632, x630, x620, x617);
var x633: u32 = undefined;
var x634: u1 = undefined;
addcarryxU32(&x633, &x634, x632, x618, x615);
var x635: u32 = undefined;
var x636: u1 = undefined;
addcarryxU32(&x635, &x636, x634, x616, x613);
var x637: u32 = undefined;
var x638: u1 = undefined;
addcarryxU32(&x637, &x638, x636, x614, x611);
var x639: u32 = undefined;
var x640: u1 = undefined;
addcarryxU32(&x639, &x640, x638, x612, x609);
var x641: u32 = undefined;
var x642: u1 = undefined;
addcarryxU32(&x641, &x642, x640, x610, x607);
const x643 = (cast(u32, x642) + x608);
var x644: u32 = undefined;
var x645: u1 = undefined;
addcarryxU32(&x644, &x645, 0x0, x581, x625);
var x646: u32 = undefined;
var x647: u1 = undefined;
addcarryxU32(&x646, &x647, x645, x583, x626);
var x648: u32 = undefined;
var x649: u1 = undefined;
addcarryxU32(&x648, &x649, x647, x585, cast(u32, 0x0));
var x650: u32 = undefined;
var x651: u1 = undefined;
addcarryxU32(&x650, &x651, x649, x587, x623);
var x652: u32 = undefined;
var x653: u1 = undefined;
addcarryxU32(&x652, &x653, x651, x589, x627);
var x654: u32 = undefined;
var x655: u1 = undefined;
addcarryxU32(&x654, &x655, x653, x591, x629);
var x656: u32 = undefined;
var x657: u1 = undefined;
addcarryxU32(&x656, &x657, x655, x593, x631);
var x658: u32 = undefined;
var x659: u1 = undefined;
addcarryxU32(&x658, &x659, x657, x595, x633);
var x660: u32 = undefined;
var x661: u1 = undefined;
addcarryxU32(&x660, &x661, x659, x597, x635);
var x662: u32 = undefined;
var x663: u1 = undefined;
addcarryxU32(&x662, &x663, x661, x599, x637);
var x664: u32 = undefined;
var x665: u1 = undefined;
addcarryxU32(&x664, &x665, x663, x601, x639);
var x666: u32 = undefined;
var x667: u1 = undefined;
addcarryxU32(&x666, &x667, x665, x603, x641);
var x668: u32 = undefined;
var x669: u1 = undefined;
addcarryxU32(&x668, &x669, x667, x605, x643);
const x670 = (cast(u32, x669) + cast(u32, x606));
var x671: u32 = undefined;
var x672: u32 = undefined;
mulxU32(&x671, &x672, x5, (arg2[11]));
var x673: u32 = undefined;
var x674: u32 = undefined;
mulxU32(&x673, &x674, x5, (arg2[10]));
var x675: u32 = undefined;
var x676: u32 = undefined;
mulxU32(&x675, &x676, x5, (arg2[9]));
var x677: u32 = undefined;
var x678: u32 = undefined;
mulxU32(&x677, &x678, x5, (arg2[8]));
var x679: u32 = undefined;
var x680: u32 = undefined;
mulxU32(&x679, &x680, x5, (arg2[7]));
var x681: u32 = undefined;
var x682: u32 = undefined;
mulxU32(&x681, &x682, x5, (arg2[6]));
var x683: u32 = undefined;
var x684: u32 = undefined;
mulxU32(&x683, &x684, x5, (arg2[5]));
var x685: u32 = undefined;
var x686: u32 = undefined;
mulxU32(&x685, &x686, x5, (arg2[4]));
var x687: u32 = undefined;
var x688: u32 = undefined;
mulxU32(&x687, &x688, x5, (arg2[3]));
var x689: u32 = undefined;
var x690: u32 = undefined;
mulxU32(&x689, &x690, x5, (arg2[2]));
var x691: u32 = undefined;
var x692: u32 = undefined;
mulxU32(&x691, &x692, x5, (arg2[1]));
var x693: u32 = undefined;
var x694: u32 = undefined;
mulxU32(&x693, &x694, x5, (arg2[0]));
var x695: u32 = undefined;
var x696: u1 = undefined;
addcarryxU32(&x695, &x696, 0x0, x694, x691);
var x697: u32 = undefined;
var x698: u1 = undefined;
addcarryxU32(&x697, &x698, x696, x692, x689);
var x699: u32 = undefined;
var x700: u1 = undefined;
addcarryxU32(&x699, &x700, x698, x690, x687);
var x701: u32 = undefined;
var x702: u1 = undefined;
addcarryxU32(&x701, &x702, x700, x688, x685);
var x703: u32 = undefined;
var x704: u1 = undefined;
addcarryxU32(&x703, &x704, x702, x686, x683);
var x705: u32 = undefined;
var x706: u1 = undefined;
addcarryxU32(&x705, &x706, x704, x684, x681);
var x707: u32 = undefined;
var x708: u1 = undefined;
addcarryxU32(&x707, &x708, x706, x682, x679);
var x709: u32 = undefined;
var x710: u1 = undefined;
addcarryxU32(&x709, &x710, x708, x680, x677);
var x711: u32 = undefined;
var x712: u1 = undefined;
addcarryxU32(&x711, &x712, x710, x678, x675);
var x713: u32 = undefined;
var x714: u1 = undefined;
addcarryxU32(&x713, &x714, x712, x676, x673);
var x715: u32 = undefined;
var x716: u1 = undefined;
addcarryxU32(&x715, &x716, x714, x674, x671);
const x717 = (cast(u32, x716) + x672);
var x718: u32 = undefined;
var x719: u1 = undefined;
addcarryxU32(&x718, &x719, 0x0, x646, x693);
var x720: u32 = undefined;
var x721: u1 = undefined;
addcarryxU32(&x720, &x721, x719, x648, x695);
var x722: u32 = undefined;
var x723: u1 = undefined;
addcarryxU32(&x722, &x723, x721, x650, x697);
var x724: u32 = undefined;
var x725: u1 = undefined;
addcarryxU32(&x724, &x725, x723, x652, x699);
var x726: u32 = undefined;
var x727: u1 = undefined;
addcarryxU32(&x726, &x727, x725, x654, x701);
var x728: u32 = undefined;
var x729: u1 = undefined;
addcarryxU32(&x728, &x729, x727, x656, x703);
var x730: u32 = undefined;
var x731: u1 = undefined;
addcarryxU32(&x730, &x731, x729, x658, x705);
var x732: u32 = undefined;
var x733: u1 = undefined;
addcarryxU32(&x732, &x733, x731, x660, x707);
var x734: u32 = undefined;
var x735: u1 = undefined;
addcarryxU32(&x734, &x735, x733, x662, x709);
var x736: u32 = undefined;
var x737: u1 = undefined;
addcarryxU32(&x736, &x737, x735, x664, x711);
var x738: u32 = undefined;
var x739: u1 = undefined;
addcarryxU32(&x738, &x739, x737, x666, x713);
var x740: u32 = undefined;
var x741: u1 = undefined;
addcarryxU32(&x740, &x741, x739, x668, x715);
var x742: u32 = undefined;
var x743: u1 = undefined;
addcarryxU32(&x742, &x743, x741, x670, x717);
var x744: u32 = undefined;
var x745: u32 = undefined;
mulxU32(&x744, &x745, x718, 0xffffffff);
var x746: u32 = undefined;
var x747: u32 = undefined;
mulxU32(&x746, &x747, x718, 0xffffffff);
var x748: u32 = undefined;
var x749: u32 = undefined;
mulxU32(&x748, &x749, x718, 0xffffffff);
var x750: u32 = undefined;
var x751: u32 = undefined;
mulxU32(&x750, &x751, x718, 0xffffffff);
var x752: u32 = undefined;
var x753: u32 = undefined;
mulxU32(&x752, &x753, x718, 0xffffffff);
var x754: u32 = undefined;
var x755: u32 = undefined;
mulxU32(&x754, &x755, x718, 0xffffffff);
var x756: u32 = undefined;
var x757: u32 = undefined;
mulxU32(&x756, &x757, x718, 0xffffffff);
var x758: u32 = undefined;
var x759: u32 = undefined;
mulxU32(&x758, &x759, x718, 0xfffffffe);
var x760: u32 = undefined;
var x761: u32 = undefined;
mulxU32(&x760, &x761, x718, 0xffffffff);
var x762: u32 = undefined;
var x763: u32 = undefined;
mulxU32(&x762, &x763, x718, 0xffffffff);
var x764: u32 = undefined;
var x765: u1 = undefined;
addcarryxU32(&x764, &x765, 0x0, x761, x758);
var x766: u32 = undefined;
var x767: u1 = undefined;
addcarryxU32(&x766, &x767, x765, x759, x756);
var x768: u32 = undefined;
var x769: u1 = undefined;
addcarryxU32(&x768, &x769, x767, x757, x754);
var x770: u32 = undefined;
var x771: u1 = undefined;
addcarryxU32(&x770, &x771, x769, x755, x752);
var x772: u32 = undefined;
var x773: u1 = undefined;
addcarryxU32(&x772, &x773, x771, x753, x750);
var x774: u32 = undefined;
var x775: u1 = undefined;
addcarryxU32(&x774, &x775, x773, x751, x748);
var x776: u32 = undefined;
var x777: u1 = undefined;
addcarryxU32(&x776, &x777, x775, x749, x746);
var x778: u32 = undefined;
var x779: u1 = undefined;
addcarryxU32(&x778, &x779, x777, x747, x744);
const x780 = (cast(u32, x779) + x745);
var x781: u32 = undefined;
var x782: u1 = undefined;
addcarryxU32(&x781, &x782, 0x0, x718, x762);
var x783: u32 = undefined;
var x784: u1 = undefined;
addcarryxU32(&x783, &x784, x782, x720, x763);
var x785: u32 = undefined;
var x786: u1 = undefined;
addcarryxU32(&x785, &x786, x784, x722, cast(u32, 0x0));
var x787: u32 = undefined;
var x788: u1 = undefined;
addcarryxU32(&x787, &x788, x786, x724, x760);
var x789: u32 = undefined;
var x790: u1 = undefined;
addcarryxU32(&x789, &x790, x788, x726, x764);
var x791: u32 = undefined;
var x792: u1 = undefined;
addcarryxU32(&x791, &x792, x790, x728, x766);
var x793: u32 = undefined;
var x794: u1 = undefined;
addcarryxU32(&x793, &x794, x792, x730, x768);
var x795: u32 = undefined;
var x796: u1 = undefined;
addcarryxU32(&x795, &x796, x794, x732, x770);
var x797: u32 = undefined;
var x798: u1 = undefined;
addcarryxU32(&x797, &x798, x796, x734, x772);
var x799: u32 = undefined;
var x800: u1 = undefined;
addcarryxU32(&x799, &x800, x798, x736, x774);
var x801: u32 = undefined;
var x802: u1 = undefined;
addcarryxU32(&x801, &x802, x800, x738, x776);
var x803: u32 = undefined;
var x804: u1 = undefined;
addcarryxU32(&x803, &x804, x802, x740, x778);
var x805: u32 = undefined;
var x806: u1 = undefined;
addcarryxU32(&x805, &x806, x804, x742, x780);
const x807 = (cast(u32, x806) + cast(u32, x743));
var x808: u32 = undefined;
var x809: u32 = undefined;
mulxU32(&x808, &x809, x6, (arg2[11]));
var x810: u32 = undefined;
var x811: u32 = undefined;
mulxU32(&x810, &x811, x6, (arg2[10]));
var x812: u32 = undefined;
var x813: u32 = undefined;
mulxU32(&x812, &x813, x6, (arg2[9]));
var x814: u32 = undefined;
var x815: u32 = undefined;
mulxU32(&x814, &x815, x6, (arg2[8]));
var x816: u32 = undefined;
var x817: u32 = undefined;
mulxU32(&x816, &x817, x6, (arg2[7]));
var x818: u32 = undefined;
var x819: u32 = undefined;
mulxU32(&x818, &x819, x6, (arg2[6]));
var x820: u32 = undefined;
var x821: u32 = undefined;
mulxU32(&x820, &x821, x6, (arg2[5]));
var x822: u32 = undefined;
var x823: u32 = undefined;
mulxU32(&x822, &x823, x6, (arg2[4]));
var x824: u32 = undefined;
var x825: u32 = undefined;
mulxU32(&x824, &x825, x6, (arg2[3]));
var x826: u32 = undefined;
var x827: u32 = undefined;
mulxU32(&x826, &x827, x6, (arg2[2]));
var x828: u32 = undefined;
var x829: u32 = undefined;
mulxU32(&x828, &x829, x6, (arg2[1]));
var x830: u32 = undefined;
var x831: u32 = undefined;
mulxU32(&x830, &x831, x6, (arg2[0]));
var x832: u32 = undefined;
var x833: u1 = undefined;
addcarryxU32(&x832, &x833, 0x0, x831, x828);
var x834: u32 = undefined;
var x835: u1 = undefined;
addcarryxU32(&x834, &x835, x833, x829, x826);
var x836: u32 = undefined;
var x837: u1 = undefined;
addcarryxU32(&x836, &x837, x835, x827, x824);
var x838: u32 = undefined;
var x839: u1 = undefined;
addcarryxU32(&x838, &x839, x837, x825, x822);
var x840: u32 = undefined;
var x841: u1 = undefined;
addcarryxU32(&x840, &x841, x839, x823, x820);
var x842: u32 = undefined;
var x843: u1 = undefined;
addcarryxU32(&x842, &x843, x841, x821, x818);
var x844: u32 = undefined;
var x845: u1 = undefined;
addcarryxU32(&x844, &x845, x843, x819, x816);
var x846: u32 = undefined;
var x847: u1 = undefined;
addcarryxU32(&x846, &x847, x845, x817, x814);
var x848: u32 = undefined;
var x849: u1 = undefined;
addcarryxU32(&x848, &x849, x847, x815, x812);
var x850: u32 = undefined;
var x851: u1 = undefined;
addcarryxU32(&x850, &x851, x849, x813, x810);
var x852: u32 = undefined;
var x853: u1 = undefined;
addcarryxU32(&x852, &x853, x851, x811, x808);
const x854 = (cast(u32, x853) + x809);
var x855: u32 = undefined;
var x856: u1 = undefined;
addcarryxU32(&x855, &x856, 0x0, x783, x830);
var x857: u32 = undefined;
var x858: u1 = undefined;
addcarryxU32(&x857, &x858, x856, x785, x832);
var x859: u32 = undefined;
var x860: u1 = undefined;
addcarryxU32(&x859, &x860, x858, x787, x834);
var x861: u32 = undefined;
var x862: u1 = undefined;
addcarryxU32(&x861, &x862, x860, x789, x836);
var x863: u32 = undefined;
var x864: u1 = undefined;
addcarryxU32(&x863, &x864, x862, x791, x838);
var x865: u32 = undefined;
var x866: u1 = undefined;
addcarryxU32(&x865, &x866, x864, x793, x840);
var x867: u32 = undefined;
var x868: u1 = undefined;
addcarryxU32(&x867, &x868, x866, x795, x842);
var x869: u32 = undefined;
var x870: u1 = undefined;
addcarryxU32(&x869, &x870, x868, x797, x844);
var x871: u32 = undefined;
var x872: u1 = undefined;
addcarryxU32(&x871, &x872, x870, x799, x846);
var x873: u32 = undefined;
var x874: u1 = undefined;
addcarryxU32(&x873, &x874, x872, x801, x848);
var x875: u32 = undefined;
var x876: u1 = undefined;
addcarryxU32(&x875, &x876, x874, x803, x850);
var x877: u32 = undefined;
var x878: u1 = undefined;
addcarryxU32(&x877, &x878, x876, x805, x852);
var x879: u32 = undefined;
var x880: u1 = undefined;
addcarryxU32(&x879, &x880, x878, x807, x854);
var x881: u32 = undefined;
var x882: u32 = undefined;
mulxU32(&x881, &x882, x855, 0xffffffff);
var x883: u32 = undefined;
var x884: u32 = undefined;
mulxU32(&x883, &x884, x855, 0xffffffff);
var x885: u32 = undefined;
var x886: u32 = undefined;
mulxU32(&x885, &x886, x855, 0xffffffff);
var x887: u32 = undefined;
var x888: u32 = undefined;
mulxU32(&x887, &x888, x855, 0xffffffff);
var x889: u32 = undefined;
var x890: u32 = undefined;
mulxU32(&x889, &x890, x855, 0xffffffff);
var x891: u32 = undefined;
var x892: u32 = undefined;
mulxU32(&x891, &x892, x855, 0xffffffff);
var x893: u32 = undefined;
var x894: u32 = undefined;
mulxU32(&x893, &x894, x855, 0xffffffff);
var x895: u32 = undefined;
var x896: u32 = undefined;
mulxU32(&x895, &x896, x855, 0xfffffffe);
var x897: u32 = undefined;
var x898: u32 = undefined;
mulxU32(&x897, &x898, x855, 0xffffffff);
var x899: u32 = undefined;
var x900: u32 = undefined;
mulxU32(&x899, &x900, x855, 0xffffffff);
var x901: u32 = undefined;
var x902: u1 = undefined;
addcarryxU32(&x901, &x902, 0x0, x898, x895);
var x903: u32 = undefined;
var x904: u1 = undefined;
addcarryxU32(&x903, &x904, x902, x896, x893);
var x905: u32 = undefined;
var x906: u1 = undefined;
addcarryxU32(&x905, &x906, x904, x894, x891);
var x907: u32 = undefined;
var x908: u1 = undefined;
addcarryxU32(&x907, &x908, x906, x892, x889);
var x909: u32 = undefined;
var x910: u1 = undefined;
addcarryxU32(&x909, &x910, x908, x890, x887);
var x911: u32 = undefined;
var x912: u1 = undefined;
addcarryxU32(&x911, &x912, x910, x888, x885);
var x913: u32 = undefined;
var x914: u1 = undefined;
addcarryxU32(&x913, &x914, x912, x886, x883);
var x915: u32 = undefined;
var x916: u1 = undefined;
addcarryxU32(&x915, &x916, x914, x884, x881);
const x917 = (cast(u32, x916) + x882);
var x918: u32 = undefined;
var x919: u1 = undefined;
addcarryxU32(&x918, &x919, 0x0, x855, x899);
var x920: u32 = undefined;
var x921: u1 = undefined;
addcarryxU32(&x920, &x921, x919, x857, x900);
var x922: u32 = undefined;
var x923: u1 = undefined;
addcarryxU32(&x922, &x923, x921, x859, cast(u32, 0x0));
var x924: u32 = undefined;
var x925: u1 = undefined;
addcarryxU32(&x924, &x925, x923, x861, x897);
var x926: u32 = undefined;
var x927: u1 = undefined;
addcarryxU32(&x926, &x927, x925, x863, x901);
var x928: u32 = undefined;
var x929: u1 = undefined;
addcarryxU32(&x928, &x929, x927, x865, x903);
var x930: u32 = undefined;
var x931: u1 = undefined;
addcarryxU32(&x930, &x931, x929, x867, x905);
var x932: u32 = undefined;
var x933: u1 = undefined;
addcarryxU32(&x932, &x933, x931, x869, x907);
var x934: u32 = undefined;
var x935: u1 = undefined;
addcarryxU32(&x934, &x935, x933, x871, x909);
var x936: u32 = undefined;
var x937: u1 = undefined;
addcarryxU32(&x936, &x937, x935, x873, x911);
var x938: u32 = undefined;
var x939: u1 = undefined;
addcarryxU32(&x938, &x939, x937, x875, x913);
var x940: u32 = undefined;
var x941: u1 = undefined;
addcarryxU32(&x940, &x941, x939, x877, x915);
var x942: u32 = undefined;
var x943: u1 = undefined;
addcarryxU32(&x942, &x943, x941, x879, x917);
const x944 = (cast(u32, x943) + cast(u32, x880));
var x945: u32 = undefined;
var x946: u32 = undefined;
mulxU32(&x945, &x946, x7, (arg2[11]));
var x947: u32 = undefined;
var x948: u32 = undefined;
mulxU32(&x947, &x948, x7, (arg2[10]));
var x949: u32 = undefined;
var x950: u32 = undefined;
mulxU32(&x949, &x950, x7, (arg2[9]));
var x951: u32 = undefined;
var x952: u32 = undefined;
mulxU32(&x951, &x952, x7, (arg2[8]));
var x953: u32 = undefined;
var x954: u32 = undefined;
mulxU32(&x953, &x954, x7, (arg2[7]));
var x955: u32 = undefined;
var x956: u32 = undefined;
mulxU32(&x955, &x956, x7, (arg2[6]));
var x957: u32 = undefined;
var x958: u32 = undefined;
mulxU32(&x957, &x958, x7, (arg2[5]));
var x959: u32 = undefined;
var x960: u32 = undefined;
mulxU32(&x959, &x960, x7, (arg2[4]));
var x961: u32 = undefined;
var x962: u32 = undefined;
mulxU32(&x961, &x962, x7, (arg2[3]));
var x963: u32 = undefined;
var x964: u32 = undefined;
mulxU32(&x963, &x964, x7, (arg2[2]));
var x965: u32 = undefined;
var x966: u32 = undefined;
mulxU32(&x965, &x966, x7, (arg2[1]));
var x967: u32 = undefined;
var x968: u32 = undefined;
mulxU32(&x967, &x968, x7, (arg2[0]));
var x969: u32 = undefined;
var x970: u1 = undefined;
addcarryxU32(&x969, &x970, 0x0, x968, x965);
var x971: u32 = undefined;
var x972: u1 = undefined;
addcarryxU32(&x971, &x972, x970, x966, x963);
var x973: u32 = undefined;
var x974: u1 = undefined;
addcarryxU32(&x973, &x974, x972, x964, x961);
var x975: u32 = undefined;
var x976: u1 = undefined;
addcarryxU32(&x975, &x976, x974, x962, x959);
var x977: u32 = undefined;
var x978: u1 = undefined;
addcarryxU32(&x977, &x978, x976, x960, x957);
var x979: u32 = undefined;
var x980: u1 = undefined;
addcarryxU32(&x979, &x980, x978, x958, x955);
var x981: u32 = undefined;
var x982: u1 = undefined;
addcarryxU32(&x981, &x982, x980, x956, x953);
var x983: u32 = undefined;
var x984: u1 = undefined;
addcarryxU32(&x983, &x984, x982, x954, x951);
var x985: u32 = undefined;
var x986: u1 = undefined;
addcarryxU32(&x985, &x986, x984, x952, x949);
var x987: u32 = undefined;
var x988: u1 = undefined;
addcarryxU32(&x987, &x988, x986, x950, x947);
var x989: u32 = undefined;
var x990: u1 = undefined;
addcarryxU32(&x989, &x990, x988, x948, x945);
const x991 = (cast(u32, x990) + x946);
var x992: u32 = undefined;
var x993: u1 = undefined;
addcarryxU32(&x992, &x993, 0x0, x920, x967);
var x994: u32 = undefined;
var x995: u1 = undefined;
addcarryxU32(&x994, &x995, x993, x922, x969);
var x996: u32 = undefined;
var x997: u1 = undefined;
addcarryxU32(&x996, &x997, x995, x924, x971);
var x998: u32 = undefined;
var x999: u1 = undefined;
addcarryxU32(&x998, &x999, x997, x926, x973);
var x1000: u32 = undefined;
var x1001: u1 = undefined;
addcarryxU32(&x1000, &x1001, x999, x928, x975);
var x1002: u32 = undefined;
var x1003: u1 = undefined;
addcarryxU32(&x1002, &x1003, x1001, x930, x977);
var x1004: u32 = undefined;
var x1005: u1 = undefined;
addcarryxU32(&x1004, &x1005, x1003, x932, x979);
var x1006: u32 = undefined;
var x1007: u1 = undefined;
addcarryxU32(&x1006, &x1007, x1005, x934, x981);
var x1008: u32 = undefined;
var x1009: u1 = undefined;
addcarryxU32(&x1008, &x1009, x1007, x936, x983);
var x1010: u32 = undefined;
var x1011: u1 = undefined;
addcarryxU32(&x1010, &x1011, x1009, x938, x985);
var x1012: u32 = undefined;
var x1013: u1 = undefined;
addcarryxU32(&x1012, &x1013, x1011, x940, x987);
var x1014: u32 = undefined;
var x1015: u1 = undefined;
addcarryxU32(&x1014, &x1015, x1013, x942, x989);
var x1016: u32 = undefined;
var x1017: u1 = undefined;
addcarryxU32(&x1016, &x1017, x1015, x944, x991);
var x1018: u32 = undefined;
var x1019: u32 = undefined;
mulxU32(&x1018, &x1019, x992, 0xffffffff);
var x1020: u32 = undefined;
var x1021: u32 = undefined;
mulxU32(&x1020, &x1021, x992, 0xffffffff);
var x1022: u32 = undefined;
var x1023: u32 = undefined;
mulxU32(&x1022, &x1023, x992, 0xffffffff);
var x1024: u32 = undefined;
var x1025: u32 = undefined;
mulxU32(&x1024, &x1025, x992, 0xffffffff);
var x1026: u32 = undefined;
var x1027: u32 = undefined;
mulxU32(&x1026, &x1027, x992, 0xffffffff);
var x1028: u32 = undefined;
var x1029: u32 = undefined;
mulxU32(&x1028, &x1029, x992, 0xffffffff);
var x1030: u32 = undefined;
var x1031: u32 = undefined;
mulxU32(&x1030, &x1031, x992, 0xffffffff);
var x1032: u32 = undefined;
var x1033: u32 = undefined;
mulxU32(&x1032, &x1033, x992, 0xfffffffe);
var x1034: u32 = undefined;
var x1035: u32 = undefined;
mulxU32(&x1034, &x1035, x992, 0xffffffff);
var x1036: u32 = undefined;
var x1037: u32 = undefined;
mulxU32(&x1036, &x1037, x992, 0xffffffff);
var x1038: u32 = undefined;
var x1039: u1 = undefined;
addcarryxU32(&x1038, &x1039, 0x0, x1035, x1032);
var x1040: u32 = undefined;
var x1041: u1 = undefined;
addcarryxU32(&x1040, &x1041, x1039, x1033, x1030);
var x1042: u32 = undefined;
var x1043: u1 = undefined;
addcarryxU32(&x1042, &x1043, x1041, x1031, x1028);
var x1044: u32 = undefined;
var x1045: u1 = undefined;
addcarryxU32(&x1044, &x1045, x1043, x1029, x1026);
var x1046: u32 = undefined;
var x1047: u1 = undefined;
addcarryxU32(&x1046, &x1047, x1045, x1027, x1024);
var x1048: u32 = undefined;
var x1049: u1 = undefined;
addcarryxU32(&x1048, &x1049, x1047, x1025, x1022);
var x1050: u32 = undefined;
var x1051: u1 = undefined;
addcarryxU32(&x1050, &x1051, x1049, x1023, x1020);
var x1052: u32 = undefined;
var x1053: u1 = undefined;
addcarryxU32(&x1052, &x1053, x1051, x1021, x1018);
const x1054 = (cast(u32, x1053) + x1019);
var x1055: u32 = undefined;
var x1056: u1 = undefined;
addcarryxU32(&x1055, &x1056, 0x0, x992, x1036);
var x1057: u32 = undefined;
var x1058: u1 = undefined;
addcarryxU32(&x1057, &x1058, x1056, x994, x1037);
var x1059: u32 = undefined;
var x1060: u1 = undefined;
addcarryxU32(&x1059, &x1060, x1058, x996, cast(u32, 0x0));
var x1061: u32 = undefined;
var x1062: u1 = undefined;
addcarryxU32(&x1061, &x1062, x1060, x998, x1034);
var x1063: u32 = undefined;
var x1064: u1 = undefined;
addcarryxU32(&x1063, &x1064, x1062, x1000, x1038);
var x1065: u32 = undefined;
var x1066: u1 = undefined;
addcarryxU32(&x1065, &x1066, x1064, x1002, x1040);
var x1067: u32 = undefined;
var x1068: u1 = undefined;
addcarryxU32(&x1067, &x1068, x1066, x1004, x1042);
var x1069: u32 = undefined;
var x1070: u1 = undefined;
addcarryxU32(&x1069, &x1070, x1068, x1006, x1044);
var x1071: u32 = undefined;
var x1072: u1 = undefined;
addcarryxU32(&x1071, &x1072, x1070, x1008, x1046);
var x1073: u32 = undefined;
var x1074: u1 = undefined;
addcarryxU32(&x1073, &x1074, x1072, x1010, x1048);
var x1075: u32 = undefined;
var x1076: u1 = undefined;
addcarryxU32(&x1075, &x1076, x1074, x1012, x1050);
var x1077: u32 = undefined;
var x1078: u1 = undefined;
addcarryxU32(&x1077, &x1078, x1076, x1014, x1052);
var x1079: u32 = undefined;
var x1080: u1 = undefined;
addcarryxU32(&x1079, &x1080, x1078, x1016, x1054);
const x1081 = (cast(u32, x1080) + cast(u32, x1017));
var x1082: u32 = undefined;
var x1083: u32 = undefined;
mulxU32(&x1082, &x1083, x8, (arg2[11]));
var x1084: u32 = undefined;
var x1085: u32 = undefined;
mulxU32(&x1084, &x1085, x8, (arg2[10]));
var x1086: u32 = undefined;
var x1087: u32 = undefined;
mulxU32(&x1086, &x1087, x8, (arg2[9]));
var x1088: u32 = undefined;
var x1089: u32 = undefined;
mulxU32(&x1088, &x1089, x8, (arg2[8]));
var x1090: u32 = undefined;
var x1091: u32 = undefined;
mulxU32(&x1090, &x1091, x8, (arg2[7]));
var x1092: u32 = undefined;
var x1093: u32 = undefined;
mulxU32(&x1092, &x1093, x8, (arg2[6]));
var x1094: u32 = undefined;
var x1095: u32 = undefined;
mulxU32(&x1094, &x1095, x8, (arg2[5]));
var x1096: u32 = undefined;
var x1097: u32 = undefined;
mulxU32(&x1096, &x1097, x8, (arg2[4]));
var x1098: u32 = undefined;
var x1099: u32 = undefined;
mulxU32(&x1098, &x1099, x8, (arg2[3]));
var x1100: u32 = undefined;
var x1101: u32 = undefined;
mulxU32(&x1100, &x1101, x8, (arg2[2]));
var x1102: u32 = undefined;
var x1103: u32 = undefined;
mulxU32(&x1102, &x1103, x8, (arg2[1]));
var x1104: u32 = undefined;
var x1105: u32 = undefined;
mulxU32(&x1104, &x1105, x8, (arg2[0]));
var x1106: u32 = undefined;
var x1107: u1 = undefined;
addcarryxU32(&x1106, &x1107, 0x0, x1105, x1102);
var x1108: u32 = undefined;
var x1109: u1 = undefined;
addcarryxU32(&x1108, &x1109, x1107, x1103, x1100);
var x1110: u32 = undefined;
var x1111: u1 = undefined;
addcarryxU32(&x1110, &x1111, x1109, x1101, x1098);
var x1112: u32 = undefined;
var x1113: u1 = undefined;
addcarryxU32(&x1112, &x1113, x1111, x1099, x1096);
var x1114: u32 = undefined;
var x1115: u1 = undefined;
addcarryxU32(&x1114, &x1115, x1113, x1097, x1094);
var x1116: u32 = undefined;
var x1117: u1 = undefined;
addcarryxU32(&x1116, &x1117, x1115, x1095, x1092);
var x1118: u32 = undefined;
var x1119: u1 = undefined;
addcarryxU32(&x1118, &x1119, x1117, x1093, x1090);
var x1120: u32 = undefined;
var x1121: u1 = undefined;
addcarryxU32(&x1120, &x1121, x1119, x1091, x1088);
var x1122: u32 = undefined;
var x1123: u1 = undefined;
addcarryxU32(&x1122, &x1123, x1121, x1089, x1086);
var x1124: u32 = undefined;
var x1125: u1 = undefined;
addcarryxU32(&x1124, &x1125, x1123, x1087, x1084);
var x1126: u32 = undefined;
var x1127: u1 = undefined;
addcarryxU32(&x1126, &x1127, x1125, x1085, x1082);
const x1128 = (cast(u32, x1127) + x1083);
var x1129: u32 = undefined;
var x1130: u1 = undefined;
addcarryxU32(&x1129, &x1130, 0x0, x1057, x1104);
var x1131: u32 = undefined;
var x1132: u1 = undefined;
addcarryxU32(&x1131, &x1132, x1130, x1059, x1106);
var x1133: u32 = undefined;
var x1134: u1 = undefined;
addcarryxU32(&x1133, &x1134, x1132, x1061, x1108);
var x1135: u32 = undefined;
var x1136: u1 = undefined;
addcarryxU32(&x1135, &x1136, x1134, x1063, x1110);
var x1137: u32 = undefined;
var x1138: u1 = undefined;
addcarryxU32(&x1137, &x1138, x1136, x1065, x1112);
var x1139: u32 = undefined;
var x1140: u1 = undefined;
addcarryxU32(&x1139, &x1140, x1138, x1067, x1114);
var x1141: u32 = undefined;
var x1142: u1 = undefined;
addcarryxU32(&x1141, &x1142, x1140, x1069, x1116);
var x1143: u32 = undefined;
var x1144: u1 = undefined;
addcarryxU32(&x1143, &x1144, x1142, x1071, x1118);
var x1145: u32 = undefined;
var x1146: u1 = undefined;
addcarryxU32(&x1145, &x1146, x1144, x1073, x1120);
var x1147: u32 = undefined;
var x1148: u1 = undefined;
addcarryxU32(&x1147, &x1148, x1146, x1075, x1122);
var x1149: u32 = undefined;
var x1150: u1 = undefined;
addcarryxU32(&x1149, &x1150, x1148, x1077, x1124);
var x1151: u32 = undefined;
var x1152: u1 = undefined;
addcarryxU32(&x1151, &x1152, x1150, x1079, x1126);
var x1153: u32 = undefined;
var x1154: u1 = undefined;
addcarryxU32(&x1153, &x1154, x1152, x1081, x1128);
var x1155: u32 = undefined;
var x1156: u32 = undefined;
mulxU32(&x1155, &x1156, x1129, 0xffffffff);
var x1157: u32 = undefined;
var x1158: u32 = undefined;
mulxU32(&x1157, &x1158, x1129, 0xffffffff);
var x1159: u32 = undefined;
var x1160: u32 = undefined;
mulxU32(&x1159, &x1160, x1129, 0xffffffff);
var x1161: u32 = undefined;
var x1162: u32 = undefined;
mulxU32(&x1161, &x1162, x1129, 0xffffffff);
var x1163: u32 = undefined;
var x1164: u32 = undefined;
mulxU32(&x1163, &x1164, x1129, 0xffffffff);
var x1165: u32 = undefined;
var x1166: u32 = undefined;
mulxU32(&x1165, &x1166, x1129, 0xffffffff);
var x1167: u32 = undefined;
var x1168: u32 = undefined;
mulxU32(&x1167, &x1168, x1129, 0xffffffff);
var x1169: u32 = undefined;
var x1170: u32 = undefined;
mulxU32(&x1169, &x1170, x1129, 0xfffffffe);
var x1171: u32 = undefined;
var x1172: u32 = undefined;
mulxU32(&x1171, &x1172, x1129, 0xffffffff);
var x1173: u32 = undefined;
var x1174: u32 = undefined;
mulxU32(&x1173, &x1174, x1129, 0xffffffff);
var x1175: u32 = undefined;
var x1176: u1 = undefined;
addcarryxU32(&x1175, &x1176, 0x0, x1172, x1169);
var x1177: u32 = undefined;
var x1178: u1 = undefined;
addcarryxU32(&x1177, &x1178, x1176, x1170, x1167);
var x1179: u32 = undefined;
var x1180: u1 = undefined;
addcarryxU32(&x1179, &x1180, x1178, x1168, x1165);
var x1181: u32 = undefined;
var x1182: u1 = undefined;
addcarryxU32(&x1181, &x1182, x1180, x1166, x1163);
var x1183: u32 = undefined;
var x1184: u1 = undefined;
addcarryxU32(&x1183, &x1184, x1182, x1164, x1161);
var x1185: u32 = undefined;
var x1186: u1 = undefined;
addcarryxU32(&x1185, &x1186, x1184, x1162, x1159);
var x1187: u32 = undefined;
var x1188: u1 = undefined;
addcarryxU32(&x1187, &x1188, x1186, x1160, x1157);
var x1189: u32 = undefined;
var x1190: u1 = undefined;
addcarryxU32(&x1189, &x1190, x1188, x1158, x1155);
const x1191 = (cast(u32, x1190) + x1156);
var x1192: u32 = undefined;
var x1193: u1 = undefined;
addcarryxU32(&x1192, &x1193, 0x0, x1129, x1173);
var x1194: u32 = undefined;
var x1195: u1 = undefined;
addcarryxU32(&x1194, &x1195, x1193, x1131, x1174);
var x1196: u32 = undefined;
var x1197: u1 = undefined;
addcarryxU32(&x1196, &x1197, x1195, x1133, cast(u32, 0x0));
var x1198: u32 = undefined;
var x1199: u1 = undefined;
addcarryxU32(&x1198, &x1199, x1197, x1135, x1171);
var x1200: u32 = undefined;
var x1201: u1 = undefined;
addcarryxU32(&x1200, &x1201, x1199, x1137, x1175);
var x1202: u32 = undefined;
var x1203: u1 = undefined;
addcarryxU32(&x1202, &x1203, x1201, x1139, x1177);
var x1204: u32 = undefined;
var x1205: u1 = undefined;
addcarryxU32(&x1204, &x1205, x1203, x1141, x1179);
var x1206: u32 = undefined;
var x1207: u1 = undefined;
addcarryxU32(&x1206, &x1207, x1205, x1143, x1181);
var x1208: u32 = undefined;
var x1209: u1 = undefined;
addcarryxU32(&x1208, &x1209, x1207, x1145, x1183);
var x1210: u32 = undefined;
var x1211: u1 = undefined;
addcarryxU32(&x1210, &x1211, x1209, x1147, x1185);
var x1212: u32 = undefined;
var x1213: u1 = undefined;
addcarryxU32(&x1212, &x1213, x1211, x1149, x1187);
var x1214: u32 = undefined;
var x1215: u1 = undefined;
addcarryxU32(&x1214, &x1215, x1213, x1151, x1189);
var x1216: u32 = undefined;
var x1217: u1 = undefined;
addcarryxU32(&x1216, &x1217, x1215, x1153, x1191);
const x1218 = (cast(u32, x1217) + cast(u32, x1154));
var x1219: u32 = undefined;
var x1220: u32 = undefined;
mulxU32(&x1219, &x1220, x9, (arg2[11]));
var x1221: u32 = undefined;
var x1222: u32 = undefined;
mulxU32(&x1221, &x1222, x9, (arg2[10]));
var x1223: u32 = undefined;
var x1224: u32 = undefined;
mulxU32(&x1223, &x1224, x9, (arg2[9]));
var x1225: u32 = undefined;
var x1226: u32 = undefined;
mulxU32(&x1225, &x1226, x9, (arg2[8]));
var x1227: u32 = undefined;
var x1228: u32 = undefined;
mulxU32(&x1227, &x1228, x9, (arg2[7]));
var x1229: u32 = undefined;
var x1230: u32 = undefined;
mulxU32(&x1229, &x1230, x9, (arg2[6]));
var x1231: u32 = undefined;
var x1232: u32 = undefined;
mulxU32(&x1231, &x1232, x9, (arg2[5]));
var x1233: u32 = undefined;
var x1234: u32 = undefined;
mulxU32(&x1233, &x1234, x9, (arg2[4]));
var x1235: u32 = undefined;
var x1236: u32 = undefined;
mulxU32(&x1235, &x1236, x9, (arg2[3]));
var x1237: u32 = undefined;
var x1238: u32 = undefined;
mulxU32(&x1237, &x1238, x9, (arg2[2]));
var x1239: u32 = undefined;
var x1240: u32 = undefined;
mulxU32(&x1239, &x1240, x9, (arg2[1]));
var x1241: u32 = undefined;
var x1242: u32 = undefined;
mulxU32(&x1241, &x1242, x9, (arg2[0]));
var x1243: u32 = undefined;
var x1244: u1 = undefined;
addcarryxU32(&x1243, &x1244, 0x0, x1242, x1239);
var x1245: u32 = undefined;
var x1246: u1 = undefined;
addcarryxU32(&x1245, &x1246, x1244, x1240, x1237);
var x1247: u32 = undefined;
var x1248: u1 = undefined;
addcarryxU32(&x1247, &x1248, x1246, x1238, x1235);
var x1249: u32 = undefined;
var x1250: u1 = undefined;
addcarryxU32(&x1249, &x1250, x1248, x1236, x1233);
var x1251: u32 = undefined;
var x1252: u1 = undefined;
addcarryxU32(&x1251, &x1252, x1250, x1234, x1231);
var x1253: u32 = undefined;
var x1254: u1 = undefined;
addcarryxU32(&x1253, &x1254, x1252, x1232, x1229);
var x1255: u32 = undefined;
var x1256: u1 = undefined;
addcarryxU32(&x1255, &x1256, x1254, x1230, x1227);
var x1257: u32 = undefined;
var x1258: u1 = undefined;
addcarryxU32(&x1257, &x1258, x1256, x1228, x1225);
var x1259: u32 = undefined;
var x1260: u1 = undefined;
addcarryxU32(&x1259, &x1260, x1258, x1226, x1223);
var x1261: u32 = undefined;
var x1262: u1 = undefined;
addcarryxU32(&x1261, &x1262, x1260, x1224, x1221);
var x1263: u32 = undefined;
var x1264: u1 = undefined;
addcarryxU32(&x1263, &x1264, x1262, x1222, x1219);
const x1265 = (cast(u32, x1264) + x1220);
var x1266: u32 = undefined;
var x1267: u1 = undefined;
addcarryxU32(&x1266, &x1267, 0x0, x1194, x1241);
var x1268: u32 = undefined;
var x1269: u1 = undefined;
addcarryxU32(&x1268, &x1269, x1267, x1196, x1243);
var x1270: u32 = undefined;
var x1271: u1 = undefined;
addcarryxU32(&x1270, &x1271, x1269, x1198, x1245);
var x1272: u32 = undefined;
var x1273: u1 = undefined;
addcarryxU32(&x1272, &x1273, x1271, x1200, x1247);
var x1274: u32 = undefined;
var x1275: u1 = undefined;
addcarryxU32(&x1274, &x1275, x1273, x1202, x1249);
var x1276: u32 = undefined;
var x1277: u1 = undefined;
addcarryxU32(&x1276, &x1277, x1275, x1204, x1251);
var x1278: u32 = undefined;
var x1279: u1 = undefined;
addcarryxU32(&x1278, &x1279, x1277, x1206, x1253);
var x1280: u32 = undefined;
var x1281: u1 = undefined;
addcarryxU32(&x1280, &x1281, x1279, x1208, x1255);
var x1282: u32 = undefined;
var x1283: u1 = undefined;
addcarryxU32(&x1282, &x1283, x1281, x1210, x1257);
var x1284: u32 = undefined;
var x1285: u1 = undefined;
addcarryxU32(&x1284, &x1285, x1283, x1212, x1259);
var x1286: u32 = undefined;
var x1287: u1 = undefined;
addcarryxU32(&x1286, &x1287, x1285, x1214, x1261);
var x1288: u32 = undefined;
var x1289: u1 = undefined;
addcarryxU32(&x1288, &x1289, x1287, x1216, x1263);
var x1290: u32 = undefined;
var x1291: u1 = undefined;
addcarryxU32(&x1290, &x1291, x1289, x1218, x1265);
var x1292: u32 = undefined;
var x1293: u32 = undefined;
mulxU32(&x1292, &x1293, x1266, 0xffffffff);
var x1294: u32 = undefined;
var x1295: u32 = undefined;
mulxU32(&x1294, &x1295, x1266, 0xffffffff);
var x1296: u32 = undefined;
var x1297: u32 = undefined;
mulxU32(&x1296, &x1297, x1266, 0xffffffff);
var x1298: u32 = undefined;
var x1299: u32 = undefined;
mulxU32(&x1298, &x1299, x1266, 0xffffffff);
var x1300: u32 = undefined;
var x1301: u32 = undefined;
mulxU32(&x1300, &x1301, x1266, 0xffffffff);
var x1302: u32 = undefined;
var x1303: u32 = undefined;
mulxU32(&x1302, &x1303, x1266, 0xffffffff);
var x1304: u32 = undefined;
var x1305: u32 = undefined;
mulxU32(&x1304, &x1305, x1266, 0xffffffff);
var x1306: u32 = undefined;
var x1307: u32 = undefined;
mulxU32(&x1306, &x1307, x1266, 0xfffffffe);
var x1308: u32 = undefined;
var x1309: u32 = undefined;
mulxU32(&x1308, &x1309, x1266, 0xffffffff);
var x1310: u32 = undefined;
var x1311: u32 = undefined;
mulxU32(&x1310, &x1311, x1266, 0xffffffff);
var x1312: u32 = undefined;
var x1313: u1 = undefined;
addcarryxU32(&x1312, &x1313, 0x0, x1309, x1306);
var x1314: u32 = undefined;
var x1315: u1 = undefined;
addcarryxU32(&x1314, &x1315, x1313, x1307, x1304);
var x1316: u32 = undefined;
var x1317: u1 = undefined;
addcarryxU32(&x1316, &x1317, x1315, x1305, x1302);
var x1318: u32 = undefined;
var x1319: u1 = undefined;
addcarryxU32(&x1318, &x1319, x1317, x1303, x1300);
var x1320: u32 = undefined;
var x1321: u1 = undefined;
addcarryxU32(&x1320, &x1321, x1319, x1301, x1298);
var x1322: u32 = undefined;
var x1323: u1 = undefined;
addcarryxU32(&x1322, &x1323, x1321, x1299, x1296);
var x1324: u32 = undefined;
var x1325: u1 = undefined;
addcarryxU32(&x1324, &x1325, x1323, x1297, x1294);
var x1326: u32 = undefined;
var x1327: u1 = undefined;
addcarryxU32(&x1326, &x1327, x1325, x1295, x1292);
const x1328 = (cast(u32, x1327) + x1293);
var x1329: u32 = undefined;
var x1330: u1 = undefined;
addcarryxU32(&x1329, &x1330, 0x0, x1266, x1310);
var x1331: u32 = undefined;
var x1332: u1 = undefined;
addcarryxU32(&x1331, &x1332, x1330, x1268, x1311);
var x1333: u32 = undefined;
var x1334: u1 = undefined;
addcarryxU32(&x1333, &x1334, x1332, x1270, cast(u32, 0x0));
var x1335: u32 = undefined;
var x1336: u1 = undefined;
addcarryxU32(&x1335, &x1336, x1334, x1272, x1308);
var x1337: u32 = undefined;
var x1338: u1 = undefined;
addcarryxU32(&x1337, &x1338, x1336, x1274, x1312);
var x1339: u32 = undefined;
var x1340: u1 = undefined;
addcarryxU32(&x1339, &x1340, x1338, x1276, x1314);
var x1341: u32 = undefined;
var x1342: u1 = undefined;
addcarryxU32(&x1341, &x1342, x1340, x1278, x1316);
var x1343: u32 = undefined;
var x1344: u1 = undefined;
addcarryxU32(&x1343, &x1344, x1342, x1280, x1318);
var x1345: u32 = undefined;
var x1346: u1 = undefined;
addcarryxU32(&x1345, &x1346, x1344, x1282, x1320);
var x1347: u32 = undefined;
var x1348: u1 = undefined;
addcarryxU32(&x1347, &x1348, x1346, x1284, x1322);
var x1349: u32 = undefined;
var x1350: u1 = undefined;
addcarryxU32(&x1349, &x1350, x1348, x1286, x1324);
var x1351: u32 = undefined;
var x1352: u1 = undefined;
addcarryxU32(&x1351, &x1352, x1350, x1288, x1326);
var x1353: u32 = undefined;
var x1354: u1 = undefined;
addcarryxU32(&x1353, &x1354, x1352, x1290, x1328);
const x1355 = (cast(u32, x1354) + cast(u32, x1291));
var x1356: u32 = undefined;
var x1357: u32 = undefined;
mulxU32(&x1356, &x1357, x10, (arg2[11]));
var x1358: u32 = undefined;
var x1359: u32 = undefined;
mulxU32(&x1358, &x1359, x10, (arg2[10]));
var x1360: u32 = undefined;
var x1361: u32 = undefined;
mulxU32(&x1360, &x1361, x10, (arg2[9]));
var x1362: u32 = undefined;
var x1363: u32 = undefined;
mulxU32(&x1362, &x1363, x10, (arg2[8]));
var x1364: u32 = undefined;
var x1365: u32 = undefined;
mulxU32(&x1364, &x1365, x10, (arg2[7]));
var x1366: u32 = undefined;
var x1367: u32 = undefined;
mulxU32(&x1366, &x1367, x10, (arg2[6]));
var x1368: u32 = undefined;
var x1369: u32 = undefined;
mulxU32(&x1368, &x1369, x10, (arg2[5]));
var x1370: u32 = undefined;
var x1371: u32 = undefined;
mulxU32(&x1370, &x1371, x10, (arg2[4]));
var x1372: u32 = undefined;
var x1373: u32 = undefined;
mulxU32(&x1372, &x1373, x10, (arg2[3]));
var x1374: u32 = undefined;
var x1375: u32 = undefined;
mulxU32(&x1374, &x1375, x10, (arg2[2]));
var x1376: u32 = undefined;
var x1377: u32 = undefined;
mulxU32(&x1376, &x1377, x10, (arg2[1]));
var x1378: u32 = undefined;
var x1379: u32 = undefined;
mulxU32(&x1378, &x1379, x10, (arg2[0]));
var x1380: u32 = undefined;
var x1381: u1 = undefined;
addcarryxU32(&x1380, &x1381, 0x0, x1379, x1376);
var x1382: u32 = undefined;
var x1383: u1 = undefined;
addcarryxU32(&x1382, &x1383, x1381, x1377, x1374);
var x1384: u32 = undefined;
var x1385: u1 = undefined;
addcarryxU32(&x1384, &x1385, x1383, x1375, x1372);
var x1386: u32 = undefined;
var x1387: u1 = undefined;
addcarryxU32(&x1386, &x1387, x1385, x1373, x1370);
var x1388: u32 = undefined;
var x1389: u1 = undefined;
addcarryxU32(&x1388, &x1389, x1387, x1371, x1368);
var x1390: u32 = undefined;
var x1391: u1 = undefined;
addcarryxU32(&x1390, &x1391, x1389, x1369, x1366);
var x1392: u32 = undefined;
var x1393: u1 = undefined;
addcarryxU32(&x1392, &x1393, x1391, x1367, x1364);
var x1394: u32 = undefined;
var x1395: u1 = undefined;
addcarryxU32(&x1394, &x1395, x1393, x1365, x1362);
var x1396: u32 = undefined;
var x1397: u1 = undefined;
addcarryxU32(&x1396, &x1397, x1395, x1363, x1360);
var x1398: u32 = undefined;
var x1399: u1 = undefined;
addcarryxU32(&x1398, &x1399, x1397, x1361, x1358);
var x1400: u32 = undefined;
var x1401: u1 = undefined;
addcarryxU32(&x1400, &x1401, x1399, x1359, x1356);
const x1402 = (cast(u32, x1401) + x1357);
var x1403: u32 = undefined;
var x1404: u1 = undefined;
addcarryxU32(&x1403, &x1404, 0x0, x1331, x1378);
var x1405: u32 = undefined;
var x1406: u1 = undefined;
addcarryxU32(&x1405, &x1406, x1404, x1333, x1380);
var x1407: u32 = undefined;
var x1408: u1 = undefined;
addcarryxU32(&x1407, &x1408, x1406, x1335, x1382);
var x1409: u32 = undefined;
var x1410: u1 = undefined;
addcarryxU32(&x1409, &x1410, x1408, x1337, x1384);
var x1411: u32 = undefined;
var x1412: u1 = undefined;
addcarryxU32(&x1411, &x1412, x1410, x1339, x1386);
var x1413: u32 = undefined;
var x1414: u1 = undefined;
addcarryxU32(&x1413, &x1414, x1412, x1341, x1388);
var x1415: u32 = undefined;
var x1416: u1 = undefined;
addcarryxU32(&x1415, &x1416, x1414, x1343, x1390);
var x1417: u32 = undefined;
var x1418: u1 = undefined;
addcarryxU32(&x1417, &x1418, x1416, x1345, x1392);
var x1419: u32 = undefined;
var x1420: u1 = undefined;
addcarryxU32(&x1419, &x1420, x1418, x1347, x1394);
var x1421: u32 = undefined;
var x1422: u1 = undefined;
addcarryxU32(&x1421, &x1422, x1420, x1349, x1396);
var x1423: u32 = undefined;
var x1424: u1 = undefined;
addcarryxU32(&x1423, &x1424, x1422, x1351, x1398);
var x1425: u32 = undefined;
var x1426: u1 = undefined;
addcarryxU32(&x1425, &x1426, x1424, x1353, x1400);
var x1427: u32 = undefined;
var x1428: u1 = undefined;
addcarryxU32(&x1427, &x1428, x1426, x1355, x1402);
var x1429: u32 = undefined;
var x1430: u32 = undefined;
mulxU32(&x1429, &x1430, x1403, 0xffffffff);
var x1431: u32 = undefined;
var x1432: u32 = undefined;
mulxU32(&x1431, &x1432, x1403, 0xffffffff);
var x1433: u32 = undefined;
var x1434: u32 = undefined;
mulxU32(&x1433, &x1434, x1403, 0xffffffff);
var x1435: u32 = undefined;
var x1436: u32 = undefined;
mulxU32(&x1435, &x1436, x1403, 0xffffffff);
var x1437: u32 = undefined;
var x1438: u32 = undefined;
mulxU32(&x1437, &x1438, x1403, 0xffffffff);
var x1439: u32 = undefined;
var x1440: u32 = undefined;
mulxU32(&x1439, &x1440, x1403, 0xffffffff);
var x1441: u32 = undefined;
var x1442: u32 = undefined;
mulxU32(&x1441, &x1442, x1403, 0xffffffff);
var x1443: u32 = undefined;
var x1444: u32 = undefined;
mulxU32(&x1443, &x1444, x1403, 0xfffffffe);
var x1445: u32 = undefined;
var x1446: u32 = undefined;
mulxU32(&x1445, &x1446, x1403, 0xffffffff);
var x1447: u32 = undefined;
var x1448: u32 = undefined;
mulxU32(&x1447, &x1448, x1403, 0xffffffff);
var x1449: u32 = undefined;
var x1450: u1 = undefined;
addcarryxU32(&x1449, &x1450, 0x0, x1446, x1443);
var x1451: u32 = undefined;
var x1452: u1 = undefined;
addcarryxU32(&x1451, &x1452, x1450, x1444, x1441);
var x1453: u32 = undefined;
var x1454: u1 = undefined;
addcarryxU32(&x1453, &x1454, x1452, x1442, x1439);
var x1455: u32 = undefined;
var x1456: u1 = undefined;
addcarryxU32(&x1455, &x1456, x1454, x1440, x1437);
var x1457: u32 = undefined;
var x1458: u1 = undefined;
addcarryxU32(&x1457, &x1458, x1456, x1438, x1435);
var x1459: u32 = undefined;
var x1460: u1 = undefined;
addcarryxU32(&x1459, &x1460, x1458, x1436, x1433);
var x1461: u32 = undefined;
var x1462: u1 = undefined;
addcarryxU32(&x1461, &x1462, x1460, x1434, x1431);
var x1463: u32 = undefined;
var x1464: u1 = undefined;
addcarryxU32(&x1463, &x1464, x1462, x1432, x1429);
const x1465 = (cast(u32, x1464) + x1430);
var x1466: u32 = undefined;
var x1467: u1 = undefined;
addcarryxU32(&x1466, &x1467, 0x0, x1403, x1447);
var x1468: u32 = undefined;
var x1469: u1 = undefined;
addcarryxU32(&x1468, &x1469, x1467, x1405, x1448);
var x1470: u32 = undefined;
var x1471: u1 = undefined;
addcarryxU32(&x1470, &x1471, x1469, x1407, cast(u32, 0x0));
var x1472: u32 = undefined;
var x1473: u1 = undefined;
addcarryxU32(&x1472, &x1473, x1471, x1409, x1445);
var x1474: u32 = undefined;
var x1475: u1 = undefined;
addcarryxU32(&x1474, &x1475, x1473, x1411, x1449);
var x1476: u32 = undefined;
var x1477: u1 = undefined;
addcarryxU32(&x1476, &x1477, x1475, x1413, x1451);
var x1478: u32 = undefined;
var x1479: u1 = undefined;
addcarryxU32(&x1478, &x1479, x1477, x1415, x1453);
var x1480: u32 = undefined;
var x1481: u1 = undefined;
addcarryxU32(&x1480, &x1481, x1479, x1417, x1455);
var x1482: u32 = undefined;
var x1483: u1 = undefined;
addcarryxU32(&x1482, &x1483, x1481, x1419, x1457);
var x1484: u32 = undefined;
var x1485: u1 = undefined;
addcarryxU32(&x1484, &x1485, x1483, x1421, x1459);
var x1486: u32 = undefined;
var x1487: u1 = undefined;
addcarryxU32(&x1486, &x1487, x1485, x1423, x1461);
var x1488: u32 = undefined;
var x1489: u1 = undefined;
addcarryxU32(&x1488, &x1489, x1487, x1425, x1463);
var x1490: u32 = undefined;
var x1491: u1 = undefined;
addcarryxU32(&x1490, &x1491, x1489, x1427, x1465);
const x1492 = (cast(u32, x1491) + cast(u32, x1428));
var x1493: u32 = undefined;
var x1494: u32 = undefined;
mulxU32(&x1493, &x1494, x11, (arg2[11]));
var x1495: u32 = undefined;
var x1496: u32 = undefined;
mulxU32(&x1495, &x1496, x11, (arg2[10]));
var x1497: u32 = undefined;
var x1498: u32 = undefined;
mulxU32(&x1497, &x1498, x11, (arg2[9]));
var x1499: u32 = undefined;
var x1500: u32 = undefined;
mulxU32(&x1499, &x1500, x11, (arg2[8]));
var x1501: u32 = undefined;
var x1502: u32 = undefined;
mulxU32(&x1501, &x1502, x11, (arg2[7]));
var x1503: u32 = undefined;
var x1504: u32 = undefined;
mulxU32(&x1503, &x1504, x11, (arg2[6]));
var x1505: u32 = undefined;
var x1506: u32 = undefined;
mulxU32(&x1505, &x1506, x11, (arg2[5]));
var x1507: u32 = undefined;
var x1508: u32 = undefined;
mulxU32(&x1507, &x1508, x11, (arg2[4]));
var x1509: u32 = undefined;
var x1510: u32 = undefined;
mulxU32(&x1509, &x1510, x11, (arg2[3]));
var x1511: u32 = undefined;
var x1512: u32 = undefined;
mulxU32(&x1511, &x1512, x11, (arg2[2]));
var x1513: u32 = undefined;
var x1514: u32 = undefined;
mulxU32(&x1513, &x1514, x11, (arg2[1]));
var x1515: u32 = undefined;
var x1516: u32 = undefined;
mulxU32(&x1515, &x1516, x11, (arg2[0]));
var x1517: u32 = undefined;
var x1518: u1 = undefined;
addcarryxU32(&x1517, &x1518, 0x0, x1516, x1513);
var x1519: u32 = undefined;
var x1520: u1 = undefined;
addcarryxU32(&x1519, &x1520, x1518, x1514, x1511);
var x1521: u32 = undefined;
var x1522: u1 = undefined;
addcarryxU32(&x1521, &x1522, x1520, x1512, x1509);
var x1523: u32 = undefined;
var x1524: u1 = undefined;
addcarryxU32(&x1523, &x1524, x1522, x1510, x1507);
var x1525: u32 = undefined;
var x1526: u1 = undefined;
addcarryxU32(&x1525, &x1526, x1524, x1508, x1505);
var x1527: u32 = undefined;
var x1528: u1 = undefined;
addcarryxU32(&x1527, &x1528, x1526, x1506, x1503);
var x1529: u32 = undefined;
var x1530: u1 = undefined;
addcarryxU32(&x1529, &x1530, x1528, x1504, x1501);
var x1531: u32 = undefined;
var x1532: u1 = undefined;
addcarryxU32(&x1531, &x1532, x1530, x1502, x1499);
var x1533: u32 = undefined;
var x1534: u1 = undefined;
addcarryxU32(&x1533, &x1534, x1532, x1500, x1497);
var x1535: u32 = undefined;
var x1536: u1 = undefined;
addcarryxU32(&x1535, &x1536, x1534, x1498, x1495);
var x1537: u32 = undefined;
var x1538: u1 = undefined;
addcarryxU32(&x1537, &x1538, x1536, x1496, x1493);
const x1539 = (cast(u32, x1538) + x1494);
var x1540: u32 = undefined;
var x1541: u1 = undefined;
addcarryxU32(&x1540, &x1541, 0x0, x1468, x1515);
var x1542: u32 = undefined;
var x1543: u1 = undefined;
addcarryxU32(&x1542, &x1543, x1541, x1470, x1517);
var x1544: u32 = undefined;
var x1545: u1 = undefined;
addcarryxU32(&x1544, &x1545, x1543, x1472, x1519);
var x1546: u32 = undefined;
var x1547: u1 = undefined;
addcarryxU32(&x1546, &x1547, x1545, x1474, x1521);
var x1548: u32 = undefined;
var x1549: u1 = undefined;
addcarryxU32(&x1548, &x1549, x1547, x1476, x1523);
var x1550: u32 = undefined;
var x1551: u1 = undefined;
addcarryxU32(&x1550, &x1551, x1549, x1478, x1525);
var x1552: u32 = undefined;
var x1553: u1 = undefined;
addcarryxU32(&x1552, &x1553, x1551, x1480, x1527);
var x1554: u32 = undefined;
var x1555: u1 = undefined;
addcarryxU32(&x1554, &x1555, x1553, x1482, x1529);
var x1556: u32 = undefined;
var x1557: u1 = undefined;
addcarryxU32(&x1556, &x1557, x1555, x1484, x1531);
var x1558: u32 = undefined;
var x1559: u1 = undefined;
addcarryxU32(&x1558, &x1559, x1557, x1486, x1533);
var x1560: u32 = undefined;
var x1561: u1 = undefined;
addcarryxU32(&x1560, &x1561, x1559, x1488, x1535);
var x1562: u32 = undefined;
var x1563: u1 = undefined;
addcarryxU32(&x1562, &x1563, x1561, x1490, x1537);
var x1564: u32 = undefined;
var x1565: u1 = undefined;
addcarryxU32(&x1564, &x1565, x1563, x1492, x1539);
var x1566: u32 = undefined;
var x1567: u32 = undefined;
mulxU32(&x1566, &x1567, x1540, 0xffffffff);
var x1568: u32 = undefined;
var x1569: u32 = undefined;
mulxU32(&x1568, &x1569, x1540, 0xffffffff);
var x1570: u32 = undefined;
var x1571: u32 = undefined;
mulxU32(&x1570, &x1571, x1540, 0xffffffff);
var x1572: u32 = undefined;
var x1573: u32 = undefined;
mulxU32(&x1572, &x1573, x1540, 0xffffffff);
var x1574: u32 = undefined;
var x1575: u32 = undefined;
mulxU32(&x1574, &x1575, x1540, 0xffffffff);
var x1576: u32 = undefined;
var x1577: u32 = undefined;
mulxU32(&x1576, &x1577, x1540, 0xffffffff);
var x1578: u32 = undefined;
var x1579: u32 = undefined;
mulxU32(&x1578, &x1579, x1540, 0xffffffff);
var x1580: u32 = undefined;
var x1581: u32 = undefined;
mulxU32(&x1580, &x1581, x1540, 0xfffffffe);
var x1582: u32 = undefined;
var x1583: u32 = undefined;
mulxU32(&x1582, &x1583, x1540, 0xffffffff);
var x1584: u32 = undefined;
var x1585: u32 = undefined;
mulxU32(&x1584, &x1585, x1540, 0xffffffff);
var x1586: u32 = undefined;
var x1587: u1 = undefined;
addcarryxU32(&x1586, &x1587, 0x0, x1583, x1580);
var x1588: u32 = undefined;
var x1589: u1 = undefined;
addcarryxU32(&x1588, &x1589, x1587, x1581, x1578);
var x1590: u32 = undefined;
var x1591: u1 = undefined;
addcarryxU32(&x1590, &x1591, x1589, x1579, x1576);
var x1592: u32 = undefined;
var x1593: u1 = undefined;
addcarryxU32(&x1592, &x1593, x1591, x1577, x1574);
var x1594: u32 = undefined;
var x1595: u1 = undefined;
addcarryxU32(&x1594, &x1595, x1593, x1575, x1572);
var x1596: u32 = undefined;
var x1597: u1 = undefined;
addcarryxU32(&x1596, &x1597, x1595, x1573, x1570);
var x1598: u32 = undefined;
var x1599: u1 = undefined;
addcarryxU32(&x1598, &x1599, x1597, x1571, x1568);
var x1600: u32 = undefined;
var x1601: u1 = undefined;
addcarryxU32(&x1600, &x1601, x1599, x1569, x1566);
const x1602 = (cast(u32, x1601) + x1567);
var x1603: u32 = undefined;
var x1604: u1 = undefined;
addcarryxU32(&x1603, &x1604, 0x0, x1540, x1584);
var x1605: u32 = undefined;
var x1606: u1 = undefined;
addcarryxU32(&x1605, &x1606, x1604, x1542, x1585);
var x1607: u32 = undefined;
var x1608: u1 = undefined;
addcarryxU32(&x1607, &x1608, x1606, x1544, cast(u32, 0x0));
var x1609: u32 = undefined;
var x1610: u1 = undefined;
addcarryxU32(&x1609, &x1610, x1608, x1546, x1582);
var x1611: u32 = undefined;
var x1612: u1 = undefined;
addcarryxU32(&x1611, &x1612, x1610, x1548, x1586);
var x1613: u32 = undefined;
var x1614: u1 = undefined;
addcarryxU32(&x1613, &x1614, x1612, x1550, x1588);
var x1615: u32 = undefined;
var x1616: u1 = undefined;
addcarryxU32(&x1615, &x1616, x1614, x1552, x1590);
var x1617: u32 = undefined;
var x1618: u1 = undefined;
addcarryxU32(&x1617, &x1618, x1616, x1554, x1592);
var x1619: u32 = undefined;
var x1620: u1 = undefined;
addcarryxU32(&x1619, &x1620, x1618, x1556, x1594);
var x1621: u32 = undefined;
var x1622: u1 = undefined;
addcarryxU32(&x1621, &x1622, x1620, x1558, x1596);
var x1623: u32 = undefined;
var x1624: u1 = undefined;
addcarryxU32(&x1623, &x1624, x1622, x1560, x1598);
var x1625: u32 = undefined;
var x1626: u1 = undefined;
addcarryxU32(&x1625, &x1626, x1624, x1562, x1600);
var x1627: u32 = undefined;
var x1628: u1 = undefined;
addcarryxU32(&x1627, &x1628, x1626, x1564, x1602);
const x1629 = (cast(u32, x1628) + cast(u32, x1565));
var x1630: u32 = undefined;
var x1631: u1 = undefined;
subborrowxU32(&x1630, &x1631, 0x0, x1605, 0xffffffff);
var x1632: u32 = undefined;
var x1633: u1 = undefined;
subborrowxU32(&x1632, &x1633, x1631, x1607, cast(u32, 0x0));
var x1634: u32 = undefined;
var x1635: u1 = undefined;
subborrowxU32(&x1634, &x1635, x1633, x1609, cast(u32, 0x0));
var x1636: u32 = undefined;
var x1637: u1 = undefined;
subborrowxU32(&x1636, &x1637, x1635, x1611, 0xffffffff);
var x1638: u32 = undefined;
var x1639: u1 = undefined;
subborrowxU32(&x1638, &x1639, x1637, x1613, 0xfffffffe);
var x1640: u32 = undefined;
var x1641: u1 = undefined;
subborrowxU32(&x1640, &x1641, x1639, x1615, 0xffffffff);
var x1642: u32 = undefined;
var x1643: u1 = undefined;
subborrowxU32(&x1642, &x1643, x1641, x1617, 0xffffffff);
var x1644: u32 = undefined;
var x1645: u1 = undefined;
subborrowxU32(&x1644, &x1645, x1643, x1619, 0xffffffff);
var x1646: u32 = undefined;
var x1647: u1 = undefined;
subborrowxU32(&x1646, &x1647, x1645, x1621, 0xffffffff);
var x1648: u32 = undefined;
var x1649: u1 = undefined;
subborrowxU32(&x1648, &x1649, x1647, x1623, 0xffffffff);
var x1650: u32 = undefined;
var x1651: u1 = undefined;
subborrowxU32(&x1650, &x1651, x1649, x1625, 0xffffffff);
var x1652: u32 = undefined;
var x1653: u1 = undefined;
subborrowxU32(&x1652, &x1653, x1651, x1627, 0xffffffff);
var x1654: u32 = undefined;
var x1655: u1 = undefined;
subborrowxU32(&x1654, &x1655, x1653, x1629, cast(u32, 0x0));
var x1656: u32 = undefined;
cmovznzU32(&x1656, x1655, x1630, x1605);
var x1657: u32 = undefined;
cmovznzU32(&x1657, x1655, x1632, x1607);
var x1658: u32 = undefined;
cmovznzU32(&x1658, x1655, x1634, x1609);
var x1659: u32 = undefined;
cmovznzU32(&x1659, x1655, x1636, x1611);
var x1660: u32 = undefined;
cmovznzU32(&x1660, x1655, x1638, x1613);
var x1661: u32 = undefined;
cmovznzU32(&x1661, x1655, x1640, x1615);
var x1662: u32 = undefined;
cmovznzU32(&x1662, x1655, x1642, x1617);
var x1663: u32 = undefined;
cmovznzU32(&x1663, x1655, x1644, x1619);
var x1664: u32 = undefined;
cmovznzU32(&x1664, x1655, x1646, x1621);
var x1665: u32 = undefined;
cmovznzU32(&x1665, x1655, x1648, x1623);
var x1666: u32 = undefined;
cmovznzU32(&x1666, x1655, x1650, x1625);
var x1667: u32 = undefined;
cmovznzU32(&x1667, x1655, x1652, x1627);
out1[0] = x1656;
out1[1] = x1657;
out1[2] = x1658;
out1[3] = x1659;
out1[4] = x1660;
out1[5] = x1661;
out1[6] = x1662;
out1[7] = x1663;
out1[8] = x1664;
out1[9] = x1665;
out1[10] = x1666;
out1[11] = x1667;
}
/// The function square squares a field element in the Montgomery domain.
///
/// Preconditions:
/// 0 ≤ eval arg1 < m
/// Postconditions:
/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m
/// 0 ≤ eval out1 < m
///
pub fn square(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement) void {
@setRuntimeSafety(mode == .Debug);
const x1 = (arg1[1]);
const x2 = (arg1[2]);
const x3 = (arg1[3]);
const x4 = (arg1[4]);
const x5 = (arg1[5]);
const x6 = (arg1[6]);
const x7 = (arg1[7]);
const x8 = (arg1[8]);
const x9 = (arg1[9]);
const x10 = (arg1[10]);
const x11 = (arg1[11]);
const x12 = (arg1[0]);
var x13: u32 = undefined;
var x14: u32 = undefined;
mulxU32(&x13, &x14, x12, (arg1[11]));
var x15: u32 = undefined;
var x16: u32 = undefined;
mulxU32(&x15, &x16, x12, (arg1[10]));
var x17: u32 = undefined;
var x18: u32 = undefined;
mulxU32(&x17, &x18, x12, (arg1[9]));
var x19: u32 = undefined;
var x20: u32 = undefined;
mulxU32(&x19, &x20, x12, (arg1[8]));
var x21: u32 = undefined;
var x22: u32 = undefined;
mulxU32(&x21, &x22, x12, (arg1[7]));
var x23: u32 = undefined;
var x24: u32 = undefined;
mulxU32(&x23, &x24, x12, (arg1[6]));
var x25: u32 = undefined;
var x26: u32 = undefined;
mulxU32(&x25, &x26, x12, (arg1[5]));
var x27: u32 = undefined;
var x28: u32 = undefined;
mulxU32(&x27, &x28, x12, (arg1[4]));
var x29: u32 = undefined;
var x30: u32 = undefined;
mulxU32(&x29, &x30, x12, (arg1[3]));
var x31: u32 = undefined;
var x32: u32 = undefined;
mulxU32(&x31, &x32, x12, (arg1[2]));
var x33: u32 = undefined;
var x34: u32 = undefined;
mulxU32(&x33, &x34, x12, (arg1[1]));
var x35: u32 = undefined;
var x36: u32 = undefined;
mulxU32(&x35, &x36, x12, (arg1[0]));
var x37: u32 = undefined;
var x38: u1 = undefined;
addcarryxU32(&x37, &x38, 0x0, x36, x33);
var x39: u32 = undefined;
var x40: u1 = undefined;
addcarryxU32(&x39, &x40, x38, x34, x31);
var x41: u32 = undefined;
var x42: u1 = undefined;
addcarryxU32(&x41, &x42, x40, x32, x29);
var x43: u32 = undefined;
var x44: u1 = undefined;
addcarryxU32(&x43, &x44, x42, x30, x27);
var x45: u32 = undefined;
var x46: u1 = undefined;
addcarryxU32(&x45, &x46, x44, x28, x25);
var x47: u32 = undefined;
var x48: u1 = undefined;
addcarryxU32(&x47, &x48, x46, x26, x23);
var x49: u32 = undefined;
var x50: u1 = undefined;
addcarryxU32(&x49, &x50, x48, x24, x21);
var x51: u32 = undefined;
var x52: u1 = undefined;
addcarryxU32(&x51, &x52, x50, x22, x19);
var x53: u32 = undefined;
var x54: u1 = undefined;
addcarryxU32(&x53, &x54, x52, x20, x17);
var x55: u32 = undefined;
var x56: u1 = undefined;
addcarryxU32(&x55, &x56, x54, x18, x15);
var x57: u32 = undefined;
var x58: u1 = undefined;
addcarryxU32(&x57, &x58, x56, x16, x13);
const x59 = (cast(u32, x58) + x14);
var x60: u32 = undefined;
var x61: u32 = undefined;
mulxU32(&x60, &x61, x35, 0xffffffff);
var x62: u32 = undefined;
var x63: u32 = undefined;
mulxU32(&x62, &x63, x35, 0xffffffff);
var x64: u32 = undefined;
var x65: u32 = undefined;
mulxU32(&x64, &x65, x35, 0xffffffff);
var x66: u32 = undefined;
var x67: u32 = undefined;
mulxU32(&x66, &x67, x35, 0xffffffff);
var x68: u32 = undefined;
var x69: u32 = undefined;
mulxU32(&x68, &x69, x35, 0xffffffff);
var x70: u32 = undefined;
var x71: u32 = undefined;
mulxU32(&x70, &x71, x35, 0xffffffff);
var x72: u32 = undefined;
var x73: u32 = undefined;
mulxU32(&x72, &x73, x35, 0xffffffff);
var x74: u32 = undefined;
var x75: u32 = undefined;
mulxU32(&x74, &x75, x35, 0xfffffffe);
var x76: u32 = undefined;
var x77: u32 = undefined;
mulxU32(&x76, &x77, x35, 0xffffffff);
var x78: u32 = undefined;
var x79: u32 = undefined;
mulxU32(&x78, &x79, x35, 0xffffffff);
var x80: u32 = undefined;
var x81: u1 = undefined;
addcarryxU32(&x80, &x81, 0x0, x77, x74);
var x82: u32 = undefined;
var x83: u1 = undefined;
addcarryxU32(&x82, &x83, x81, x75, x72);
var x84: u32 = undefined;
var x85: u1 = undefined;
addcarryxU32(&x84, &x85, x83, x73, x70);
var x86: u32 = undefined;
var x87: u1 = undefined;
addcarryxU32(&x86, &x87, x85, x71, x68);
var x88: u32 = undefined;
var x89: u1 = undefined;
addcarryxU32(&x88, &x89, x87, x69, x66);
var x90: u32 = undefined;
var x91: u1 = undefined;
addcarryxU32(&x90, &x91, x89, x67, x64);
var x92: u32 = undefined;
var x93: u1 = undefined;
addcarryxU32(&x92, &x93, x91, x65, x62);
var x94: u32 = undefined;
var x95: u1 = undefined;
addcarryxU32(&x94, &x95, x93, x63, x60);
const x96 = (cast(u32, x95) + x61);
var x97: u32 = undefined;
var x98: u1 = undefined;
addcarryxU32(&x97, &x98, 0x0, x35, x78);
var x99: u32 = undefined;
var x100: u1 = undefined;
addcarryxU32(&x99, &x100, x98, x37, x79);
var x101: u32 = undefined;
var x102: u1 = undefined;
addcarryxU32(&x101, &x102, x100, x39, cast(u32, 0x0));
var x103: u32 = undefined;
var x104: u1 = undefined;
addcarryxU32(&x103, &x104, x102, x41, x76);
var x105: u32 = undefined;
var x106: u1 = undefined;
addcarryxU32(&x105, &x106, x104, x43, x80);
var x107: u32 = undefined;
var x108: u1 = undefined;
addcarryxU32(&x107, &x108, x106, x45, x82);
var x109: u32 = undefined;
var x110: u1 = undefined;
addcarryxU32(&x109, &x110, x108, x47, x84);
var x111: u32 = undefined;
var x112: u1 = undefined;
addcarryxU32(&x111, &x112, x110, x49, x86);
var x113: u32 = undefined;
var x114: u1 = undefined;
addcarryxU32(&x113, &x114, x112, x51, x88);
var x115: u32 = undefined;
var x116: u1 = undefined;
addcarryxU32(&x115, &x116, x114, x53, x90);
var x117: u32 = undefined;
var x118: u1 = undefined;
addcarryxU32(&x117, &x118, x116, x55, x92);
var x119: u32 = undefined;
var x120: u1 = undefined;
addcarryxU32(&x119, &x120, x118, x57, x94);
var x121: u32 = undefined;
var x122: u1 = undefined;
addcarryxU32(&x121, &x122, x120, x59, x96);
var x123: u32 = undefined;
var x124: u32 = undefined;
mulxU32(&x123, &x124, x1, (arg1[11]));
var x125: u32 = undefined;
var x126: u32 = undefined;
mulxU32(&x125, &x126, x1, (arg1[10]));
var x127: u32 = undefined;
var x128: u32 = undefined;
mulxU32(&x127, &x128, x1, (arg1[9]));
var x129: u32 = undefined;
var x130: u32 = undefined;
mulxU32(&x129, &x130, x1, (arg1[8]));
var x131: u32 = undefined;
var x132: u32 = undefined;
mulxU32(&x131, &x132, x1, (arg1[7]));
var x133: u32 = undefined;
var x134: u32 = undefined;
mulxU32(&x133, &x134, x1, (arg1[6]));
var x135: u32 = undefined;
var x136: u32 = undefined;
mulxU32(&x135, &x136, x1, (arg1[5]));
var x137: u32 = undefined;
var x138: u32 = undefined;
mulxU32(&x137, &x138, x1, (arg1[4]));
var x139: u32 = undefined;
var x140: u32 = undefined;
mulxU32(&x139, &x140, x1, (arg1[3]));
var x141: u32 = undefined;
var x142: u32 = undefined;
mulxU32(&x141, &x142, x1, (arg1[2]));
var x143: u32 = undefined;
var x144: u32 = undefined;
mulxU32(&x143, &x144, x1, (arg1[1]));
var x145: u32 = undefined;
var x146: u32 = undefined;
mulxU32(&x145, &x146, x1, (arg1[0]));
var x147: u32 = undefined;
var x148: u1 = undefined;
addcarryxU32(&x147, &x148, 0x0, x146, x143);
var x149: u32 = undefined;
var x150: u1 = undefined;
addcarryxU32(&x149, &x150, x148, x144, x141);
var x151: u32 = undefined;
var x152: u1 = undefined;
addcarryxU32(&x151, &x152, x150, x142, x139);
var x153: u32 = undefined;
var x154: u1 = undefined;
addcarryxU32(&x153, &x154, x152, x140, x137);
var x155: u32 = undefined;
var x156: u1 = undefined;
addcarryxU32(&x155, &x156, x154, x138, x135);
var x157: u32 = undefined;
var x158: u1 = undefined;
addcarryxU32(&x157, &x158, x156, x136, x133);
var x159: u32 = undefined;
var x160: u1 = undefined;
addcarryxU32(&x159, &x160, x158, x134, x131);
var x161: u32 = undefined;
var x162: u1 = undefined;
addcarryxU32(&x161, &x162, x160, x132, x129);
var x163: u32 = undefined;
var x164: u1 = undefined;
addcarryxU32(&x163, &x164, x162, x130, x127);
var x165: u32 = undefined;
var x166: u1 = undefined;
addcarryxU32(&x165, &x166, x164, x128, x125);
var x167: u32 = undefined;
var x168: u1 = undefined;
addcarryxU32(&x167, &x168, x166, x126, x123);
const x169 = (cast(u32, x168) + x124);
var x170: u32 = undefined;
var x171: u1 = undefined;
addcarryxU32(&x170, &x171, 0x0, x99, x145);
var x172: u32 = undefined;
var x173: u1 = undefined;
addcarryxU32(&x172, &x173, x171, x101, x147);
var x174: u32 = undefined;
var x175: u1 = undefined;
addcarryxU32(&x174, &x175, x173, x103, x149);
var x176: u32 = undefined;
var x177: u1 = undefined;
addcarryxU32(&x176, &x177, x175, x105, x151);
var x178: u32 = undefined;
var x179: u1 = undefined;
addcarryxU32(&x178, &x179, x177, x107, x153);
var x180: u32 = undefined;
var x181: u1 = undefined;
addcarryxU32(&x180, &x181, x179, x109, x155);
var x182: u32 = undefined;
var x183: u1 = undefined;
addcarryxU32(&x182, &x183, x181, x111, x157);
var x184: u32 = undefined;
var x185: u1 = undefined;
addcarryxU32(&x184, &x185, x183, x113, x159);
var x186: u32 = undefined;
var x187: u1 = undefined;
addcarryxU32(&x186, &x187, x185, x115, x161);
var x188: u32 = undefined;
var x189: u1 = undefined;
addcarryxU32(&x188, &x189, x187, x117, x163);
var x190: u32 = undefined;
var x191: u1 = undefined;
addcarryxU32(&x190, &x191, x189, x119, x165);
var x192: u32 = undefined;
var x193: u1 = undefined;
addcarryxU32(&x192, &x193, x191, x121, x167);
var x194: u32 = undefined;
var x195: u1 = undefined;
addcarryxU32(&x194, &x195, x193, cast(u32, x122), x169);
var x196: u32 = undefined;
var x197: u32 = undefined;
mulxU32(&x196, &x197, x170, 0xffffffff);
var x198: u32 = undefined;
var x199: u32 = undefined;
mulxU32(&x198, &x199, x170, 0xffffffff);
var x200: u32 = undefined;
var x201: u32 = undefined;
mulxU32(&x200, &x201, x170, 0xffffffff);
var x202: u32 = undefined;
var x203: u32 = undefined;
mulxU32(&x202, &x203, x170, 0xffffffff);
var x204: u32 = undefined;
var x205: u32 = undefined;
mulxU32(&x204, &x205, x170, 0xffffffff);
var x206: u32 = undefined;
var x207: u32 = undefined;
mulxU32(&x206, &x207, x170, 0xffffffff);
var x208: u32 = undefined;
var x209: u32 = undefined;
mulxU32(&x208, &x209, x170, 0xffffffff);
var x210: u32 = undefined;
var x211: u32 = undefined;
mulxU32(&x210, &x211, x170, 0xfffffffe);
var x212: u32 = undefined;
var x213: u32 = undefined;
mulxU32(&x212, &x213, x170, 0xffffffff);
var x214: u32 = undefined;
var x215: u32 = undefined;
mulxU32(&x214, &x215, x170, 0xffffffff);
var x216: u32 = undefined;
var x217: u1 = undefined;
addcarryxU32(&x216, &x217, 0x0, x213, x210);
var x218: u32 = undefined;
var x219: u1 = undefined;
addcarryxU32(&x218, &x219, x217, x211, x208);
var x220: u32 = undefined;
var x221: u1 = undefined;
addcarryxU32(&x220, &x221, x219, x209, x206);
var x222: u32 = undefined;
var x223: u1 = undefined;
addcarryxU32(&x222, &x223, x221, x207, x204);
var x224: u32 = undefined;
var x225: u1 = undefined;
addcarryxU32(&x224, &x225, x223, x205, x202);
var x226: u32 = undefined;
var x227: u1 = undefined;
addcarryxU32(&x226, &x227, x225, x203, x200);
var x228: u32 = undefined;
var x229: u1 = undefined;
addcarryxU32(&x228, &x229, x227, x201, x198);
var x230: u32 = undefined;
var x231: u1 = undefined;
addcarryxU32(&x230, &x231, x229, x199, x196);
const x232 = (cast(u32, x231) + x197);
var x233: u32 = undefined;
var x234: u1 = undefined;
addcarryxU32(&x233, &x234, 0x0, x170, x214);
var x235: u32 = undefined;
var x236: u1 = undefined;
addcarryxU32(&x235, &x236, x234, x172, x215);
var x237: u32 = undefined;
var x238: u1 = undefined;
addcarryxU32(&x237, &x238, x236, x174, cast(u32, 0x0));
var x239: u32 = undefined;
var x240: u1 = undefined;
addcarryxU32(&x239, &x240, x238, x176, x212);
var x241: u32 = undefined;
var x242: u1 = undefined;
addcarryxU32(&x241, &x242, x240, x178, x216);
var x243: u32 = undefined;
var x244: u1 = undefined;
addcarryxU32(&x243, &x244, x242, x180, x218);
var x245: u32 = undefined;
var x246: u1 = undefined;
addcarryxU32(&x245, &x246, x244, x182, x220);
var x247: u32 = undefined;
var x248: u1 = undefined;
addcarryxU32(&x247, &x248, x246, x184, x222);
var x249: u32 = undefined;
var x250: u1 = undefined;
addcarryxU32(&x249, &x250, x248, x186, x224);
var x251: u32 = undefined;
var x252: u1 = undefined;
addcarryxU32(&x251, &x252, x250, x188, x226);
var x253: u32 = undefined;
var x254: u1 = undefined;
addcarryxU32(&x253, &x254, x252, x190, x228);
var x255: u32 = undefined;
var x256: u1 = undefined;
addcarryxU32(&x255, &x256, x254, x192, x230);
var x257: u32 = undefined;
var x258: u1 = undefined;
addcarryxU32(&x257, &x258, x256, x194, x232);
const x259 = (cast(u32, x258) + cast(u32, x195));
var x260: u32 = undefined;
var x261: u32 = undefined;
mulxU32(&x260, &x261, x2, (arg1[11]));
var x262: u32 = undefined;
var x263: u32 = undefined;
mulxU32(&x262, &x263, x2, (arg1[10]));
var x264: u32 = undefined;
var x265: u32 = undefined;
mulxU32(&x264, &x265, x2, (arg1[9]));
var x266: u32 = undefined;
var x267: u32 = undefined;
mulxU32(&x266, &x267, x2, (arg1[8]));
var x268: u32 = undefined;
var x269: u32 = undefined;
mulxU32(&x268, &x269, x2, (arg1[7]));
var x270: u32 = undefined;
var x271: u32 = undefined;
mulxU32(&x270, &x271, x2, (arg1[6]));
var x272: u32 = undefined;
var x273: u32 = undefined;
mulxU32(&x272, &x273, x2, (arg1[5]));
var x274: u32 = undefined;
var x275: u32 = undefined;
mulxU32(&x274, &x275, x2, (arg1[4]));
var x276: u32 = undefined;
var x277: u32 = undefined;
mulxU32(&x276, &x277, x2, (arg1[3]));
var x278: u32 = undefined;
var x279: u32 = undefined;
mulxU32(&x278, &x279, x2, (arg1[2]));
var x280: u32 = undefined;
var x281: u32 = undefined;
mulxU32(&x280, &x281, x2, (arg1[1]));
var x282: u32 = undefined;
var x283: u32 = undefined;
mulxU32(&x282, &x283, x2, (arg1[0]));
var x284: u32 = undefined;
var x285: u1 = undefined;
addcarryxU32(&x284, &x285, 0x0, x283, x280);
var x286: u32 = undefined;
var x287: u1 = undefined;
addcarryxU32(&x286, &x287, x285, x281, x278);
var x288: u32 = undefined;
var x289: u1 = undefined;
addcarryxU32(&x288, &x289, x287, x279, x276);
var x290: u32 = undefined;
var x291: u1 = undefined;
addcarryxU32(&x290, &x291, x289, x277, x274);
var x292: u32 = undefined;
var x293: u1 = undefined;
addcarryxU32(&x292, &x293, x291, x275, x272);
var x294: u32 = undefined;
var x295: u1 = undefined;
addcarryxU32(&x294, &x295, x293, x273, x270);
var x296: u32 = undefined;
var x297: u1 = undefined;
addcarryxU32(&x296, &x297, x295, x271, x268);
var x298: u32 = undefined;
var x299: u1 = undefined;
addcarryxU32(&x298, &x299, x297, x269, x266);
var x300: u32 = undefined;
var x301: u1 = undefined;
addcarryxU32(&x300, &x301, x299, x267, x264);
var x302: u32 = undefined;
var x303: u1 = undefined;
addcarryxU32(&x302, &x303, x301, x265, x262);
var x304: u32 = undefined;
var x305: u1 = undefined;
addcarryxU32(&x304, &x305, x303, x263, x260);
const x306 = (cast(u32, x305) + x261);
var x307: u32 = undefined;
var x308: u1 = undefined;
addcarryxU32(&x307, &x308, 0x0, x235, x282);
var x309: u32 = undefined;
var x310: u1 = undefined;
addcarryxU32(&x309, &x310, x308, x237, x284);
var x311: u32 = undefined;
var x312: u1 = undefined;
addcarryxU32(&x311, &x312, x310, x239, x286);
var x313: u32 = undefined;
var x314: u1 = undefined;
addcarryxU32(&x313, &x314, x312, x241, x288);
var x315: u32 = undefined;
var x316: u1 = undefined;
addcarryxU32(&x315, &x316, x314, x243, x290);
var x317: u32 = undefined;
var x318: u1 = undefined;
addcarryxU32(&x317, &x318, x316, x245, x292);
var x319: u32 = undefined;
var x320: u1 = undefined;
addcarryxU32(&x319, &x320, x318, x247, x294);
var x321: u32 = undefined;
var x322: u1 = undefined;
addcarryxU32(&x321, &x322, x320, x249, x296);
var x323: u32 = undefined;
var x324: u1 = undefined;
addcarryxU32(&x323, &x324, x322, x251, x298);
var x325: u32 = undefined;
var x326: u1 = undefined;
addcarryxU32(&x325, &x326, x324, x253, x300);
var x327: u32 = undefined;
var x328: u1 = undefined;
addcarryxU32(&x327, &x328, x326, x255, x302);
var x329: u32 = undefined;
var x330: u1 = undefined;
addcarryxU32(&x329, &x330, x328, x257, x304);
var x331: u32 = undefined;
var x332: u1 = undefined;
addcarryxU32(&x331, &x332, x330, x259, x306);
var x333: u32 = undefined;
var x334: u32 = undefined;
mulxU32(&x333, &x334, x307, 0xffffffff);
var x335: u32 = undefined;
var x336: u32 = undefined;
mulxU32(&x335, &x336, x307, 0xffffffff);
var x337: u32 = undefined;
var x338: u32 = undefined;
mulxU32(&x337, &x338, x307, 0xffffffff);
var x339: u32 = undefined;
var x340: u32 = undefined;
mulxU32(&x339, &x340, x307, 0xffffffff);
var x341: u32 = undefined;
var x342: u32 = undefined;
mulxU32(&x341, &x342, x307, 0xffffffff);
var x343: u32 = undefined;
var x344: u32 = undefined;
mulxU32(&x343, &x344, x307, 0xffffffff);
var x345: u32 = undefined;
var x346: u32 = undefined;
mulxU32(&x345, &x346, x307, 0xffffffff);
var x347: u32 = undefined;
var x348: u32 = undefined;
mulxU32(&x347, &x348, x307, 0xfffffffe);
var x349: u32 = undefined;
var x350: u32 = undefined;
mulxU32(&x349, &x350, x307, 0xffffffff);
var x351: u32 = undefined;
var x352: u32 = undefined;
mulxU32(&x351, &x352, x307, 0xffffffff);
var x353: u32 = undefined;
var x354: u1 = undefined;
addcarryxU32(&x353, &x354, 0x0, x350, x347);
var x355: u32 = undefined;
var x356: u1 = undefined;
addcarryxU32(&x355, &x356, x354, x348, x345);
var x357: u32 = undefined;
var x358: u1 = undefined;
addcarryxU32(&x357, &x358, x356, x346, x343);
var x359: u32 = undefined;
var x360: u1 = undefined;
addcarryxU32(&x359, &x360, x358, x344, x341);
var x361: u32 = undefined;
var x362: u1 = undefined;
addcarryxU32(&x361, &x362, x360, x342, x339);
var x363: u32 = undefined;
var x364: u1 = undefined;
addcarryxU32(&x363, &x364, x362, x340, x337);
var x365: u32 = undefined;
var x366: u1 = undefined;
addcarryxU32(&x365, &x366, x364, x338, x335);
var x367: u32 = undefined;
var x368: u1 = undefined;
addcarryxU32(&x367, &x368, x366, x336, x333);
const x369 = (cast(u32, x368) + x334);
var x370: u32 = undefined;
var x371: u1 = undefined;
addcarryxU32(&x370, &x371, 0x0, x307, x351);
var x372: u32 = undefined;
var x373: u1 = undefined;
addcarryxU32(&x372, &x373, x371, x309, x352);
var x374: u32 = undefined;
var x375: u1 = undefined;
addcarryxU32(&x374, &x375, x373, x311, cast(u32, 0x0));
var x376: u32 = undefined;
var x377: u1 = undefined;
addcarryxU32(&x376, &x377, x375, x313, x349);
var x378: u32 = undefined;
var x379: u1 = undefined;
addcarryxU32(&x378, &x379, x377, x315, x353);
var x380: u32 = undefined;
var x381: u1 = undefined;
addcarryxU32(&x380, &x381, x379, x317, x355);
var x382: u32 = undefined;
var x383: u1 = undefined;
addcarryxU32(&x382, &x383, x381, x319, x357);
var x384: u32 = undefined;
var x385: u1 = undefined;
addcarryxU32(&x384, &x385, x383, x321, x359);
var x386: u32 = undefined;
var x387: u1 = undefined;
addcarryxU32(&x386, &x387, x385, x323, x361);
var x388: u32 = undefined;
var x389: u1 = undefined;
addcarryxU32(&x388, &x389, x387, x325, x363);
var x390: u32 = undefined;
var x391: u1 = undefined;
addcarryxU32(&x390, &x391, x389, x327, x365);
var x392: u32 = undefined;
var x393: u1 = undefined;
addcarryxU32(&x392, &x393, x391, x329, x367);
var x394: u32 = undefined;
var x395: u1 = undefined;
addcarryxU32(&x394, &x395, x393, x331, x369);
const x396 = (cast(u32, x395) + cast(u32, x332));
var x397: u32 = undefined;
var x398: u32 = undefined;
mulxU32(&x397, &x398, x3, (arg1[11]));
var x399: u32 = undefined;
var x400: u32 = undefined;
mulxU32(&x399, &x400, x3, (arg1[10]));
var x401: u32 = undefined;
var x402: u32 = undefined;
mulxU32(&x401, &x402, x3, (arg1[9]));
var x403: u32 = undefined;
var x404: u32 = undefined;
mulxU32(&x403, &x404, x3, (arg1[8]));
var x405: u32 = undefined;
var x406: u32 = undefined;
mulxU32(&x405, &x406, x3, (arg1[7]));
var x407: u32 = undefined;
var x408: u32 = undefined;
mulxU32(&x407, &x408, x3, (arg1[6]));
var x409: u32 = undefined;
var x410: u32 = undefined;
mulxU32(&x409, &x410, x3, (arg1[5]));
var x411: u32 = undefined;
var x412: u32 = undefined;
mulxU32(&x411, &x412, x3, (arg1[4]));
var x413: u32 = undefined;
var x414: u32 = undefined;
mulxU32(&x413, &x414, x3, (arg1[3]));
var x415: u32 = undefined;
var x416: u32 = undefined;
mulxU32(&x415, &x416, x3, (arg1[2]));
var x417: u32 = undefined;
var x418: u32 = undefined;
mulxU32(&x417, &x418, x3, (arg1[1]));
var x419: u32 = undefined;
var x420: u32 = undefined;
mulxU32(&x419, &x420, x3, (arg1[0]));
var x421: u32 = undefined;
var x422: u1 = undefined;
addcarryxU32(&x421, &x422, 0x0, x420, x417);
var x423: u32 = undefined;
var x424: u1 = undefined;
addcarryxU32(&x423, &x424, x422, x418, x415);
var x425: u32 = undefined;
var x426: u1 = undefined;
addcarryxU32(&x425, &x426, x424, x416, x413);
var x427: u32 = undefined;
var x428: u1 = undefined;
addcarryxU32(&x427, &x428, x426, x414, x411);
var x429: u32 = undefined;
var x430: u1 = undefined;
addcarryxU32(&x429, &x430, x428, x412, x409);
var x431: u32 = undefined;
var x432: u1 = undefined;
addcarryxU32(&x431, &x432, x430, x410, x407);
var x433: u32 = undefined;
var x434: u1 = undefined;
addcarryxU32(&x433, &x434, x432, x408, x405);
var x435: u32 = undefined;
var x436: u1 = undefined;
addcarryxU32(&x435, &x436, x434, x406, x403);
var x437: u32 = undefined;
var x438: u1 = undefined;
addcarryxU32(&x437, &x438, x436, x404, x401);
var x439: u32 = undefined;
var x440: u1 = undefined;
addcarryxU32(&x439, &x440, x438, x402, x399);
var x441: u32 = undefined;
var x442: u1 = undefined;
addcarryxU32(&x441, &x442, x440, x400, x397);
const x443 = (cast(u32, x442) + x398);
var x444: u32 = undefined;
var x445: u1 = undefined;
addcarryxU32(&x444, &x445, 0x0, x372, x419);
var x446: u32 = undefined;
var x447: u1 = undefined;
addcarryxU32(&x446, &x447, x445, x374, x421);
var x448: u32 = undefined;
var x449: u1 = undefined;
addcarryxU32(&x448, &x449, x447, x376, x423);
var x450: u32 = undefined;
var x451: u1 = undefined;
addcarryxU32(&x450, &x451, x449, x378, x425);
var x452: u32 = undefined;
var x453: u1 = undefined;
addcarryxU32(&x452, &x453, x451, x380, x427);
var x454: u32 = undefined;
var x455: u1 = undefined;
addcarryxU32(&x454, &x455, x453, x382, x429);
var x456: u32 = undefined;
var x457: u1 = undefined;
addcarryxU32(&x456, &x457, x455, x384, x431);
var x458: u32 = undefined;
var x459: u1 = undefined;
addcarryxU32(&x458, &x459, x457, x386, x433);
var x460: u32 = undefined;
var x461: u1 = undefined;
addcarryxU32(&x460, &x461, x459, x388, x435);
var x462: u32 = undefined;
var x463: u1 = undefined;
addcarryxU32(&x462, &x463, x461, x390, x437);
var x464: u32 = undefined;
var x465: u1 = undefined;
addcarryxU32(&x464, &x465, x463, x392, x439);
var x466: u32 = undefined;
var x467: u1 = undefined;
addcarryxU32(&x466, &x467, x465, x394, x441);
var x468: u32 = undefined;
var x469: u1 = undefined;
addcarryxU32(&x468, &x469, x467, x396, x443);
var x470: u32 = undefined;
var x471: u32 = undefined;
mulxU32(&x470, &x471, x444, 0xffffffff);
var x472: u32 = undefined;
var x473: u32 = undefined;
mulxU32(&x472, &x473, x444, 0xffffffff);
var x474: u32 = undefined;
var x475: u32 = undefined;
mulxU32(&x474, &x475, x444, 0xffffffff);
var x476: u32 = undefined;
var x477: u32 = undefined;
mulxU32(&x476, &x477, x444, 0xffffffff);
var x478: u32 = undefined;
var x479: u32 = undefined;
mulxU32(&x478, &x479, x444, 0xffffffff);
var x480: u32 = undefined;
var x481: u32 = undefined;
mulxU32(&x480, &x481, x444, 0xffffffff);
var x482: u32 = undefined;
var x483: u32 = undefined;
mulxU32(&x482, &x483, x444, 0xffffffff);
var x484: u32 = undefined;
var x485: u32 = undefined;
mulxU32(&x484, &x485, x444, 0xfffffffe);
var x486: u32 = undefined;
var x487: u32 = undefined;
mulxU32(&x486, &x487, x444, 0xffffffff);
var x488: u32 = undefined;
var x489: u32 = undefined;
mulxU32(&x488, &x489, x444, 0xffffffff);
var x490: u32 = undefined;
var x491: u1 = undefined;
addcarryxU32(&x490, &x491, 0x0, x487, x484);
var x492: u32 = undefined;
var x493: u1 = undefined;
addcarryxU32(&x492, &x493, x491, x485, x482);
var x494: u32 = undefined;
var x495: u1 = undefined;
addcarryxU32(&x494, &x495, x493, x483, x480);
var x496: u32 = undefined;
var x497: u1 = undefined;
addcarryxU32(&x496, &x497, x495, x481, x478);
var x498: u32 = undefined;
var x499: u1 = undefined;
addcarryxU32(&x498, &x499, x497, x479, x476);
var x500: u32 = undefined;
var x501: u1 = undefined;
addcarryxU32(&x500, &x501, x499, x477, x474);
var x502: u32 = undefined;
var x503: u1 = undefined;
addcarryxU32(&x502, &x503, x501, x475, x472);
var x504: u32 = undefined;
var x505: u1 = undefined;
addcarryxU32(&x504, &x505, x503, x473, x470);
const x506 = (cast(u32, x505) + x471);
var x507: u32 = undefined;
var x508: u1 = undefined;
addcarryxU32(&x507, &x508, 0x0, x444, x488);
var x509: u32 = undefined;
var x510: u1 = undefined;
addcarryxU32(&x509, &x510, x508, x446, x489);
var x511: u32 = undefined;
var x512: u1 = undefined;
addcarryxU32(&x511, &x512, x510, x448, cast(u32, 0x0));
var x513: u32 = undefined;
var x514: u1 = undefined;
addcarryxU32(&x513, &x514, x512, x450, x486);
var x515: u32 = undefined;
var x516: u1 = undefined;
addcarryxU32(&x515, &x516, x514, x452, x490);
var x517: u32 = undefined;
var x518: u1 = undefined;
addcarryxU32(&x517, &x518, x516, x454, x492);
var x519: u32 = undefined;
var x520: u1 = undefined;
addcarryxU32(&x519, &x520, x518, x456, x494);
var x521: u32 = undefined;
var x522: u1 = undefined;
addcarryxU32(&x521, &x522, x520, x458, x496);
var x523: u32 = undefined;
var x524: u1 = undefined;
addcarryxU32(&x523, &x524, x522, x460, x498);
var x525: u32 = undefined;
var x526: u1 = undefined;
addcarryxU32(&x525, &x526, x524, x462, x500);
var x527: u32 = undefined;
var x528: u1 = undefined;
addcarryxU32(&x527, &x528, x526, x464, x502);
var x529: u32 = undefined;
var x530: u1 = undefined;
addcarryxU32(&x529, &x530, x528, x466, x504);
var x531: u32 = undefined;
var x532: u1 = undefined;
addcarryxU32(&x531, &x532, x530, x468, x506);
const x533 = (cast(u32, x532) + cast(u32, x469));
var x534: u32 = undefined;
var x535: u32 = undefined;
mulxU32(&x534, &x535, x4, (arg1[11]));
var x536: u32 = undefined;
var x537: u32 = undefined;
mulxU32(&x536, &x537, x4, (arg1[10]));
var x538: u32 = undefined;
var x539: u32 = undefined;
mulxU32(&x538, &x539, x4, (arg1[9]));
var x540: u32 = undefined;
var x541: u32 = undefined;
mulxU32(&x540, &x541, x4, (arg1[8]));
var x542: u32 = undefined;
var x543: u32 = undefined;
mulxU32(&x542, &x543, x4, (arg1[7]));
var x544: u32 = undefined;
var x545: u32 = undefined;
mulxU32(&x544, &x545, x4, (arg1[6]));
var x546: u32 = undefined;
var x547: u32 = undefined;
mulxU32(&x546, &x547, x4, (arg1[5]));
var x548: u32 = undefined;
var x549: u32 = undefined;
mulxU32(&x548, &x549, x4, (arg1[4]));
var x550: u32 = undefined;
var x551: u32 = undefined;
mulxU32(&x550, &x551, x4, (arg1[3]));
var x552: u32 = undefined;
var x553: u32 = undefined;
mulxU32(&x552, &x553, x4, (arg1[2]));
var x554: u32 = undefined;
var x555: u32 = undefined;
mulxU32(&x554, &x555, x4, (arg1[1]));
var x556: u32 = undefined;
var x557: u32 = undefined;
mulxU32(&x556, &x557, x4, (arg1[0]));
var x558: u32 = undefined;
var x559: u1 = undefined;
addcarryxU32(&x558, &x559, 0x0, x557, x554);
var x560: u32 = undefined;
var x561: u1 = undefined;
addcarryxU32(&x560, &x561, x559, x555, x552);
var x562: u32 = undefined;
var x563: u1 = undefined;
addcarryxU32(&x562, &x563, x561, x553, x550);
var x564: u32 = undefined;
var x565: u1 = undefined;
addcarryxU32(&x564, &x565, x563, x551, x548);
var x566: u32 = undefined;
var x567: u1 = undefined;
addcarryxU32(&x566, &x567, x565, x549, x546);
var x568: u32 = undefined;
var x569: u1 = undefined;
addcarryxU32(&x568, &x569, x567, x547, x544);
var x570: u32 = undefined;
var x571: u1 = undefined;
addcarryxU32(&x570, &x571, x569, x545, x542);
var x572: u32 = undefined;
var x573: u1 = undefined;
addcarryxU32(&x572, &x573, x571, x543, x540);
var x574: u32 = undefined;
var x575: u1 = undefined;
addcarryxU32(&x574, &x575, x573, x541, x538);
var x576: u32 = undefined;
var x577: u1 = undefined;
addcarryxU32(&x576, &x577, x575, x539, x536);
var x578: u32 = undefined;
var x579: u1 = undefined;
addcarryxU32(&x578, &x579, x577, x537, x534);
const x580 = (cast(u32, x579) + x535);
var x581: u32 = undefined;
var x582: u1 = undefined;
addcarryxU32(&x581, &x582, 0x0, x509, x556);
var x583: u32 = undefined;
var x584: u1 = undefined;
addcarryxU32(&x583, &x584, x582, x511, x558);
var x585: u32 = undefined;
var x586: u1 = undefined;
addcarryxU32(&x585, &x586, x584, x513, x560);
var x587: u32 = undefined;
var x588: u1 = undefined;
addcarryxU32(&x587, &x588, x586, x515, x562);
var x589: u32 = undefined;
var x590: u1 = undefined;
addcarryxU32(&x589, &x590, x588, x517, x564);
var x591: u32 = undefined;
var x592: u1 = undefined;
addcarryxU32(&x591, &x592, x590, x519, x566);
var x593: u32 = undefined;
var x594: u1 = undefined;
addcarryxU32(&x593, &x594, x592, x521, x568);
var x595: u32 = undefined;
var x596: u1 = undefined;
addcarryxU32(&x595, &x596, x594, x523, x570);
var x597: u32 = undefined;
var x598: u1 = undefined;
addcarryxU32(&x597, &x598, x596, x525, x572);
var x599: u32 = undefined;
var x600: u1 = undefined;
addcarryxU32(&x599, &x600, x598, x527, x574);
var x601: u32 = undefined;
var x602: u1 = undefined;
addcarryxU32(&x601, &x602, x600, x529, x576);
var x603: u32 = undefined;
var x604: u1 = undefined;
addcarryxU32(&x603, &x604, x602, x531, x578);
var x605: u32 = undefined;
var x606: u1 = undefined;
addcarryxU32(&x605, &x606, x604, x533, x580);
var x607: u32 = undefined;
var x608: u32 = undefined;
mulxU32(&x607, &x608, x581, 0xffffffff);
var x609: u32 = undefined;
var x610: u32 = undefined;
mulxU32(&x609, &x610, x581, 0xffffffff);
var x611: u32 = undefined;
var x612: u32 = undefined;
mulxU32(&x611, &x612, x581, 0xffffffff);
var x613: u32 = undefined;
var x614: u32 = undefined;
mulxU32(&x613, &x614, x581, 0xffffffff);
var x615: u32 = undefined;
var x616: u32 = undefined;
mulxU32(&x615, &x616, x581, 0xffffffff);
var x617: u32 = undefined;
var x618: u32 = undefined;
mulxU32(&x617, &x618, x581, 0xffffffff);
var x619: u32 = undefined;
var x620: u32 = undefined;
mulxU32(&x619, &x620, x581, 0xffffffff);
var x621: u32 = undefined;
var x622: u32 = undefined;
mulxU32(&x621, &x622, x581, 0xfffffffe);
var x623: u32 = undefined;
var x624: u32 = undefined;
mulxU32(&x623, &x624, x581, 0xffffffff);
var x625: u32 = undefined;
var x626: u32 = undefined;
mulxU32(&x625, &x626, x581, 0xffffffff);
var x627: u32 = undefined;
var x628: u1 = undefined;
addcarryxU32(&x627, &x628, 0x0, x624, x621);
var x629: u32 = undefined;
var x630: u1 = undefined;
addcarryxU32(&x629, &x630, x628, x622, x619);
var x631: u32 = undefined;
var x632: u1 = undefined;
addcarryxU32(&x631, &x632, x630, x620, x617);
var x633: u32 = undefined;
var x634: u1 = undefined;
addcarryxU32(&x633, &x634, x632, x618, x615);
var x635: u32 = undefined;
var x636: u1 = undefined;
addcarryxU32(&x635, &x636, x634, x616, x613);
var x637: u32 = undefined;
var x638: u1 = undefined;
addcarryxU32(&x637, &x638, x636, x614, x611);
var x639: u32 = undefined;
var x640: u1 = undefined;
addcarryxU32(&x639, &x640, x638, x612, x609);
var x641: u32 = undefined;
var x642: u1 = undefined;
addcarryxU32(&x641, &x642, x640, x610, x607);
const x643 = (cast(u32, x642) + x608);
var x644: u32 = undefined;
var x645: u1 = undefined;
addcarryxU32(&x644, &x645, 0x0, x581, x625);
var x646: u32 = undefined;
var x647: u1 = undefined;
addcarryxU32(&x646, &x647, x645, x583, x626);
var x648: u32 = undefined;
var x649: u1 = undefined;
addcarryxU32(&x648, &x649, x647, x585, cast(u32, 0x0));
var x650: u32 = undefined;
var x651: u1 = undefined;
addcarryxU32(&x650, &x651, x649, x587, x623);
var x652: u32 = undefined;
var x653: u1 = undefined;
addcarryxU32(&x652, &x653, x651, x589, x627);
var x654: u32 = undefined;
var x655: u1 = undefined;
addcarryxU32(&x654, &x655, x653, x591, x629);
var x656: u32 = undefined;
var x657: u1 = undefined;
addcarryxU32(&x656, &x657, x655, x593, x631);
var x658: u32 = undefined;
var x659: u1 = undefined;
addcarryxU32(&x658, &x659, x657, x595, x633);
var x660: u32 = undefined;
var x661: u1 = undefined;
addcarryxU32(&x660, &x661, x659, x597, x635);
var x662: u32 = undefined;
var x663: u1 = undefined;
addcarryxU32(&x662, &x663, x661, x599, x637);
var x664: u32 = undefined;
var x665: u1 = undefined;
addcarryxU32(&x664, &x665, x663, x601, x639);
var x666: u32 = undefined;
var x667: u1 = undefined;
addcarryxU32(&x666, &x667, x665, x603, x641);
var x668: u32 = undefined;
var x669: u1 = undefined;
addcarryxU32(&x668, &x669, x667, x605, x643);
const x670 = (cast(u32, x669) + cast(u32, x606));
var x671: u32 = undefined;
var x672: u32 = undefined;
mulxU32(&x671, &x672, x5, (arg1[11]));
var x673: u32 = undefined;
var x674: u32 = undefined;
mulxU32(&x673, &x674, x5, (arg1[10]));
var x675: u32 = undefined;
var x676: u32 = undefined;
mulxU32(&x675, &x676, x5, (arg1[9]));
var x677: u32 = undefined;
var x678: u32 = undefined;
mulxU32(&x677, &x678, x5, (arg1[8]));
var x679: u32 = undefined;
var x680: u32 = undefined;
mulxU32(&x679, &x680, x5, (arg1[7]));
var x681: u32 = undefined;
var x682: u32 = undefined;
mulxU32(&x681, &x682, x5, (arg1[6]));
var x683: u32 = undefined;
var x684: u32 = undefined;
mulxU32(&x683, &x684, x5, (arg1[5]));
var x685: u32 = undefined;
var x686: u32 = undefined;
mulxU32(&x685, &x686, x5, (arg1[4]));
var x687: u32 = undefined;
var x688: u32 = undefined;
mulxU32(&x687, &x688, x5, (arg1[3]));
var x689: u32 = undefined;
var x690: u32 = undefined;
mulxU32(&x689, &x690, x5, (arg1[2]));
var x691: u32 = undefined;
var x692: u32 = undefined;
mulxU32(&x691, &x692, x5, (arg1[1]));
var x693: u32 = undefined;
var x694: u32 = undefined;
mulxU32(&x693, &x694, x5, (arg1[0]));
var x695: u32 = undefined;
var x696: u1 = undefined;
addcarryxU32(&x695, &x696, 0x0, x694, x691);
var x697: u32 = undefined;
var x698: u1 = undefined;
addcarryxU32(&x697, &x698, x696, x692, x689);
var x699: u32 = undefined;
var x700: u1 = undefined;
addcarryxU32(&x699, &x700, x698, x690, x687);
var x701: u32 = undefined;
var x702: u1 = undefined;
addcarryxU32(&x701, &x702, x700, x688, x685);
var x703: u32 = undefined;
var x704: u1 = undefined;
addcarryxU32(&x703, &x704, x702, x686, x683);
var x705: u32 = undefined;
var x706: u1 = undefined;
addcarryxU32(&x705, &x706, x704, x684, x681);
var x707: u32 = undefined;
var x708: u1 = undefined;
addcarryxU32(&x707, &x708, x706, x682, x679);
var x709: u32 = undefined;
var x710: u1 = undefined;
addcarryxU32(&x709, &x710, x708, x680, x677);
var x711: u32 = undefined;
var x712: u1 = undefined;
addcarryxU32(&x711, &x712, x710, x678, x675);
var x713: u32 = undefined;
var x714: u1 = undefined;
addcarryxU32(&x713, &x714, x712, x676, x673);
var x715: u32 = undefined;
var x716: u1 = undefined;
addcarryxU32(&x715, &x716, x714, x674, x671);
const x717 = (cast(u32, x716) + x672);
var x718: u32 = undefined;
var x719: u1 = undefined;
addcarryxU32(&x718, &x719, 0x0, x646, x693);
var x720: u32 = undefined;
var x721: u1 = undefined;
addcarryxU32(&x720, &x721, x719, x648, x695);
var x722: u32 = undefined;
var x723: u1 = undefined;
addcarryxU32(&x722, &x723, x721, x650, x697);
var x724: u32 = undefined;
var x725: u1 = undefined;
addcarryxU32(&x724, &x725, x723, x652, x699);
var x726: u32 = undefined;
var x727: u1 = undefined;
addcarryxU32(&x726, &x727, x725, x654, x701);
var x728: u32 = undefined;
var x729: u1 = undefined;
addcarryxU32(&x728, &x729, x727, x656, x703);
var x730: u32 = undefined;
var x731: u1 = undefined;
addcarryxU32(&x730, &x731, x729, x658, x705);
var x732: u32 = undefined;
var x733: u1 = undefined;
addcarryxU32(&x732, &x733, x731, x660, x707);
var x734: u32 = undefined;
var x735: u1 = undefined;
addcarryxU32(&x734, &x735, x733, x662, x709);
var x736: u32 = undefined;
var x737: u1 = undefined;
addcarryxU32(&x736, &x737, x735, x664, x711);
var x738: u32 = undefined;
var x739: u1 = undefined;
addcarryxU32(&x738, &x739, x737, x666, x713);
var x740: u32 = undefined;
var x741: u1 = undefined;
addcarryxU32(&x740, &x741, x739, x668, x715);
var x742: u32 = undefined;
var x743: u1 = undefined;
addcarryxU32(&x742, &x743, x741, x670, x717);
var x744: u32 = undefined;
var x745: u32 = undefined;
mulxU32(&x744, &x745, x718, 0xffffffff);
var x746: u32 = undefined;
var x747: u32 = undefined;
mulxU32(&x746, &x747, x718, 0xffffffff);
var x748: u32 = undefined;
var x749: u32 = undefined;
mulxU32(&x748, &x749, x718, 0xffffffff);
var x750: u32 = undefined;
var x751: u32 = undefined;
mulxU32(&x750, &x751, x718, 0xffffffff);
var x752: u32 = undefined;
var x753: u32 = undefined;
mulxU32(&x752, &x753, x718, 0xffffffff);
var x754: u32 = undefined;
var x755: u32 = undefined;
mulxU32(&x754, &x755, x718, 0xffffffff);
var x756: u32 = undefined;
var x757: u32 = undefined;
mulxU32(&x756, &x757, x718, 0xffffffff);
var x758: u32 = undefined;
var x759: u32 = undefined;
mulxU32(&x758, &x759, x718, 0xfffffffe);
var x760: u32 = undefined;
var x761: u32 = undefined;
mulxU32(&x760, &x761, x718, 0xffffffff);
var x762: u32 = undefined;
var x763: u32 = undefined;
mulxU32(&x762, &x763, x718, 0xffffffff);
var x764: u32 = undefined;
var x765: u1 = undefined;
addcarryxU32(&x764, &x765, 0x0, x761, x758);
var x766: u32 = undefined;
var x767: u1 = undefined;
addcarryxU32(&x766, &x767, x765, x759, x756);
var x768: u32 = undefined;
var x769: u1 = undefined;
addcarryxU32(&x768, &x769, x767, x757, x754);
var x770: u32 = undefined;
var x771: u1 = undefined;
addcarryxU32(&x770, &x771, x769, x755, x752);
var x772: u32 = undefined;
var x773: u1 = undefined;
addcarryxU32(&x772, &x773, x771, x753, x750);
var x774: u32 = undefined;
var x775: u1 = undefined;
addcarryxU32(&x774, &x775, x773, x751, x748);
var x776: u32 = undefined;
var x777: u1 = undefined;
addcarryxU32(&x776, &x777, x775, x749, x746);
var x778: u32 = undefined;
var x779: u1 = undefined;
addcarryxU32(&x778, &x779, x777, x747, x744);
const x780 = (cast(u32, x779) + x745);
var x781: u32 = undefined;
var x782: u1 = undefined;
addcarryxU32(&x781, &x782, 0x0, x718, x762);
var x783: u32 = undefined;
var x784: u1 = undefined;
addcarryxU32(&x783, &x784, x782, x720, x763);
var x785: u32 = undefined;
var x786: u1 = undefined;
addcarryxU32(&x785, &x786, x784, x722, cast(u32, 0x0));
var x787: u32 = undefined;
var x788: u1 = undefined;
addcarryxU32(&x787, &x788, x786, x724, x760);
var x789: u32 = undefined;
var x790: u1 = undefined;
addcarryxU32(&x789, &x790, x788, x726, x764);
var x791: u32 = undefined;
var x792: u1 = undefined;
addcarryxU32(&x791, &x792, x790, x728, x766);
var x793: u32 = undefined;
var x794: u1 = undefined;
addcarryxU32(&x793, &x794, x792, x730, x768);
var x795: u32 = undefined;
var x796: u1 = undefined;
addcarryxU32(&x795, &x796, x794, x732, x770);
var x797: u32 = undefined;
var x798: u1 = undefined;
addcarryxU32(&x797, &x798, x796, x734, x772);
var x799: u32 = undefined;
var x800: u1 = undefined;
addcarryxU32(&x799, &x800, x798, x736, x774);
var x801: u32 = undefined;
var x802: u1 = undefined;
addcarryxU32(&x801, &x802, x800, x738, x776);
var x803: u32 = undefined;
var x804: u1 = undefined;
addcarryxU32(&x803, &x804, x802, x740, x778);
var x805: u32 = undefined;
var x806: u1 = undefined;
addcarryxU32(&x805, &x806, x804, x742, x780);
const x807 = (cast(u32, x806) + cast(u32, x743));
var x808: u32 = undefined;
var x809: u32 = undefined;
mulxU32(&x808, &x809, x6, (arg1[11]));
var x810: u32 = undefined;
var x811: u32 = undefined;
mulxU32(&x810, &x811, x6, (arg1[10]));
var x812: u32 = undefined;
var x813: u32 = undefined;
mulxU32(&x812, &x813, x6, (arg1[9]));
var x814: u32 = undefined;
var x815: u32 = undefined;
mulxU32(&x814, &x815, x6, (arg1[8]));
var x816: u32 = undefined;
var x817: u32 = undefined;
mulxU32(&x816, &x817, x6, (arg1[7]));
var x818: u32 = undefined;
var x819: u32 = undefined;
mulxU32(&x818, &x819, x6, (arg1[6]));
var x820: u32 = undefined;
var x821: u32 = undefined;
mulxU32(&x820, &x821, x6, (arg1[5]));
var x822: u32 = undefined;
var x823: u32 = undefined;
mulxU32(&x822, &x823, x6, (arg1[4]));
var x824: u32 = undefined;
var x825: u32 = undefined;
mulxU32(&x824, &x825, x6, (arg1[3]));
var x826: u32 = undefined;
var x827: u32 = undefined;
mulxU32(&x826, &x827, x6, (arg1[2]));
var x828: u32 = undefined;
var x829: u32 = undefined;
mulxU32(&x828, &x829, x6, (arg1[1]));
var x830: u32 = undefined;
var x831: u32 = undefined;
mulxU32(&x830, &x831, x6, (arg1[0]));
var x832: u32 = undefined;
var x833: u1 = undefined;
addcarryxU32(&x832, &x833, 0x0, x831, x828);
var x834: u32 = undefined;
var x835: u1 = undefined;
addcarryxU32(&x834, &x835, x833, x829, x826);
var x836: u32 = undefined;
var x837: u1 = undefined;
addcarryxU32(&x836, &x837, x835, x827, x824);
var x838: u32 = undefined;
var x839: u1 = undefined;
addcarryxU32(&x838, &x839, x837, x825, x822);
var x840: u32 = undefined;
var x841: u1 = undefined;
addcarryxU32(&x840, &x841, x839, x823, x820);
var x842: u32 = undefined;
var x843: u1 = undefined;
addcarryxU32(&x842, &x843, x841, x821, x818);
var x844: u32 = undefined;
var x845: u1 = undefined;
addcarryxU32(&x844, &x845, x843, x819, x816);
var x846: u32 = undefined;
var x847: u1 = undefined;
addcarryxU32(&x846, &x847, x845, x817, x814);
var x848: u32 = undefined;
var x849: u1 = undefined;
addcarryxU32(&x848, &x849, x847, x815, x812);
var x850: u32 = undefined;
var x851: u1 = undefined;
addcarryxU32(&x850, &x851, x849, x813, x810);
var x852: u32 = undefined;
var x853: u1 = undefined;
addcarryxU32(&x852, &x853, x851, x811, x808);
const x854 = (cast(u32, x853) + x809);
var x855: u32 = undefined;
var x856: u1 = undefined;
addcarryxU32(&x855, &x856, 0x0, x783, x830);
var x857: u32 = undefined;
var x858: u1 = undefined;
addcarryxU32(&x857, &x858, x856, x785, x832);
var x859: u32 = undefined;
var x860: u1 = undefined;
addcarryxU32(&x859, &x860, x858, x787, x834);
var x861: u32 = undefined;
var x862: u1 = undefined;
addcarryxU32(&x861, &x862, x860, x789, x836);
var x863: u32 = undefined;
var x864: u1 = undefined;
addcarryxU32(&x863, &x864, x862, x791, x838);
var x865: u32 = undefined;
var x866: u1 = undefined;
addcarryxU32(&x865, &x866, x864, x793, x840);
var x867: u32 = undefined;
var x868: u1 = undefined;
addcarryxU32(&x867, &x868, x866, x795, x842);
var x869: u32 = undefined;
var x870: u1 = undefined;
addcarryxU32(&x869, &x870, x868, x797, x844);
var x871: u32 = undefined;
var x872: u1 = undefined;
addcarryxU32(&x871, &x872, x870, x799, x846);
var x873: u32 = undefined;
var x874: u1 = undefined;
addcarryxU32(&x873, &x874, x872, x801, x848);
var x875: u32 = undefined;
var x876: u1 = undefined;
addcarryxU32(&x875, &x876, x874, x803, x850);
var x877: u32 = undefined;
var x878: u1 = undefined;
addcarryxU32(&x877, &x878, x876, x805, x852);
var x879: u32 = undefined;
var x880: u1 = undefined;
addcarryxU32(&x879, &x880, x878, x807, x854);
var x881: u32 = undefined;
var x882: u32 = undefined;
mulxU32(&x881, &x882, x855, 0xffffffff);
var x883: u32 = undefined;
var x884: u32 = undefined;
mulxU32(&x883, &x884, x855, 0xffffffff);
var x885: u32 = undefined;
var x886: u32 = undefined;
mulxU32(&x885, &x886, x855, 0xffffffff);
var x887: u32 = undefined;
var x888: u32 = undefined;
mulxU32(&x887, &x888, x855, 0xffffffff);
var x889: u32 = undefined;
var x890: u32 = undefined;
mulxU32(&x889, &x890, x855, 0xffffffff);
var x891: u32 = undefined;
var x892: u32 = undefined;
mulxU32(&x891, &x892, x855, 0xffffffff);
var x893: u32 = undefined;
var x894: u32 = undefined;
mulxU32(&x893, &x894, x855, 0xffffffff);
var x895: u32 = undefined;
var x896: u32 = undefined;
mulxU32(&x895, &x896, x855, 0xfffffffe);
var x897: u32 = undefined;
var x898: u32 = undefined;
mulxU32(&x897, &x898, x855, 0xffffffff);
var x899: u32 = undefined;
var x900: u32 = undefined;
mulxU32(&x899, &x900, x855, 0xffffffff);
var x901: u32 = undefined;
var x902: u1 = undefined;
addcarryxU32(&x901, &x902, 0x0, x898, x895);
var x903: u32 = undefined;
var x904: u1 = undefined;
addcarryxU32(&x903, &x904, x902, x896, x893);
var x905: u32 = undefined;
var x906: u1 = undefined;
addcarryxU32(&x905, &x906, x904, x894, x891);
var x907: u32 = undefined;
var x908: u1 = undefined;
addcarryxU32(&x907, &x908, x906, x892, x889);
var x909: u32 = undefined;
var x910: u1 = undefined;
addcarryxU32(&x909, &x910, x908, x890, x887);
var x911: u32 = undefined;
var x912: u1 = undefined;
addcarryxU32(&x911, &x912, x910, x888, x885);
var x913: u32 = undefined;
var x914: u1 = undefined;
addcarryxU32(&x913, &x914, x912, x886, x883);
var x915: u32 = undefined;
var x916: u1 = undefined;
addcarryxU32(&x915, &x916, x914, x884, x881);
const x917 = (cast(u32, x916) + x882);
var x918: u32 = undefined;
var x919: u1 = undefined;
addcarryxU32(&x918, &x919, 0x0, x855, x899);
var x920: u32 = undefined;
var x921: u1 = undefined;
addcarryxU32(&x920, &x921, x919, x857, x900);
var x922: u32 = undefined;
var x923: u1 = undefined;
addcarryxU32(&x922, &x923, x921, x859, cast(u32, 0x0));
var x924: u32 = undefined;
var x925: u1 = undefined;
addcarryxU32(&x924, &x925, x923, x861, x897);
var x926: u32 = undefined;
var x927: u1 = undefined;
addcarryxU32(&x926, &x927, x925, x863, x901);
var x928: u32 = undefined;
var x929: u1 = undefined;
addcarryxU32(&x928, &x929, x927, x865, x903);
var x930: u32 = undefined;
var x931: u1 = undefined;
addcarryxU32(&x930, &x931, x929, x867, x905);
var x932: u32 = undefined;
var x933: u1 = undefined;
addcarryxU32(&x932, &x933, x931, x869, x907);
var x934: u32 = undefined;
var x935: u1 = undefined;
addcarryxU32(&x934, &x935, x933, x871, x909);
var x936: u32 = undefined;
var x937: u1 = undefined;
addcarryxU32(&x936, &x937, x935, x873, x911);
var x938: u32 = undefined;
var x939: u1 = undefined;
addcarryxU32(&x938, &x939, x937, x875, x913);
var x940: u32 = undefined;
var x941: u1 = undefined;
addcarryxU32(&x940, &x941, x939, x877, x915);
var x942: u32 = undefined;
var x943: u1 = undefined;
addcarryxU32(&x942, &x943, x941, x879, x917);
const x944 = (cast(u32, x943) + cast(u32, x880));
var x945: u32 = undefined;
var x946: u32 = undefined;
mulxU32(&x945, &x946, x7, (arg1[11]));
var x947: u32 = undefined;
var x948: u32 = undefined;
mulxU32(&x947, &x948, x7, (arg1[10]));
var x949: u32 = undefined;
var x950: u32 = undefined;
mulxU32(&x949, &x950, x7, (arg1[9]));
var x951: u32 = undefined;
var x952: u32 = undefined;
mulxU32(&x951, &x952, x7, (arg1[8]));
var x953: u32 = undefined;
var x954: u32 = undefined;
mulxU32(&x953, &x954, x7, (arg1[7]));
var x955: u32 = undefined;
var x956: u32 = undefined;
mulxU32(&x955, &x956, x7, (arg1[6]));
var x957: u32 = undefined;
var x958: u32 = undefined;
mulxU32(&x957, &x958, x7, (arg1[5]));
var x959: u32 = undefined;
var x960: u32 = undefined;
mulxU32(&x959, &x960, x7, (arg1[4]));
var x961: u32 = undefined;
var x962: u32 = undefined;
mulxU32(&x961, &x962, x7, (arg1[3]));
var x963: u32 = undefined;
var x964: u32 = undefined;
mulxU32(&x963, &x964, x7, (arg1[2]));
var x965: u32 = undefined;
var x966: u32 = undefined;
mulxU32(&x965, &x966, x7, (arg1[1]));
var x967: u32 = undefined;
var x968: u32 = undefined;
mulxU32(&x967, &x968, x7, (arg1[0]));
var x969: u32 = undefined;
var x970: u1 = undefined;
addcarryxU32(&x969, &x970, 0x0, x968, x965);
var x971: u32 = undefined;
var x972: u1 = undefined;
addcarryxU32(&x971, &x972, x970, x966, x963);
var x973: u32 = undefined;
var x974: u1 = undefined;
addcarryxU32(&x973, &x974, x972, x964, x961);
var x975: u32 = undefined;
var x976: u1 = undefined;
addcarryxU32(&x975, &x976, x974, x962, x959);
var x977: u32 = undefined;
var x978: u1 = undefined;
addcarryxU32(&x977, &x978, x976, x960, x957);
var x979: u32 = undefined;
var x980: u1 = undefined;
addcarryxU32(&x979, &x980, x978, x958, x955);
var x981: u32 = undefined;
var x982: u1 = undefined;
addcarryxU32(&x981, &x982, x980, x956, x953);
var x983: u32 = undefined;
var x984: u1 = undefined;
addcarryxU32(&x983, &x984, x982, x954, x951);
var x985: u32 = undefined;
var x986: u1 = undefined;
addcarryxU32(&x985, &x986, x984, x952, x949);
var x987: u32 = undefined;
var x988: u1 = undefined;
addcarryxU32(&x987, &x988, x986, x950, x947);
var x989: u32 = undefined;
var x990: u1 = undefined;
addcarryxU32(&x989, &x990, x988, x948, x945);
const x991 = (cast(u32, x990) + x946);
var x992: u32 = undefined;
var x993: u1 = undefined;
addcarryxU32(&x992, &x993, 0x0, x920, x967);
var x994: u32 = undefined;
var x995: u1 = undefined;
addcarryxU32(&x994, &x995, x993, x922, x969);
var x996: u32 = undefined;
var x997: u1 = undefined;
addcarryxU32(&x996, &x997, x995, x924, x971);
var x998: u32 = undefined;
var x999: u1 = undefined;
addcarryxU32(&x998, &x999, x997, x926, x973);
var x1000: u32 = undefined;
var x1001: u1 = undefined;
addcarryxU32(&x1000, &x1001, x999, x928, x975);
var x1002: u32 = undefined;
var x1003: u1 = undefined;
addcarryxU32(&x1002, &x1003, x1001, x930, x977);
var x1004: u32 = undefined;
var x1005: u1 = undefined;
addcarryxU32(&x1004, &x1005, x1003, x932, x979);
var x1006: u32 = undefined;
var x1007: u1 = undefined;
addcarryxU32(&x1006, &x1007, x1005, x934, x981);
var x1008: u32 = undefined;
var x1009: u1 = undefined;
addcarryxU32(&x1008, &x1009, x1007, x936, x983);
var x1010: u32 = undefined;
var x1011: u1 = undefined;
addcarryxU32(&x1010, &x1011, x1009, x938, x985);
var x1012: u32 = undefined;
var x1013: u1 = undefined;
addcarryxU32(&x1012, &x1013, x1011, x940, x987);
var x1014: u32 = undefined;
var x1015: u1 = undefined;
addcarryxU32(&x1014, &x1015, x1013, x942, x989);
var x1016: u32 = undefined;
var x1017: u1 = undefined;
addcarryxU32(&x1016, &x1017, x1015, x944, x991);
var x1018: u32 = undefined;
var x1019: u32 = undefined;
mulxU32(&x1018, &x1019, x992, 0xffffffff);
var x1020: u32 = undefined;
var x1021: u32 = undefined;
mulxU32(&x1020, &x1021, x992, 0xffffffff);
var x1022: u32 = undefined;
var x1023: u32 = undefined;
mulxU32(&x1022, &x1023, x992, 0xffffffff);
var x1024: u32 = undefined;
var x1025: u32 = undefined;
mulxU32(&x1024, &x1025, x992, 0xffffffff);
var x1026: u32 = undefined;
var x1027: u32 = undefined;
mulxU32(&x1026, &x1027, x992, 0xffffffff);
var x1028: u32 = undefined;
var x1029: u32 = undefined;
mulxU32(&x1028, &x1029, x992, 0xffffffff);
var x1030: u32 = undefined;
var x1031: u32 = undefined;
mulxU32(&x1030, &x1031, x992, 0xffffffff);
var x1032: u32 = undefined;
var x1033: u32 = undefined;
mulxU32(&x1032, &x1033, x992, 0xfffffffe);
var x1034: u32 = undefined;
var x1035: u32 = undefined;
mulxU32(&x1034, &x1035, x992, 0xffffffff);
var x1036: u32 = undefined;
var x1037: u32 = undefined;
mulxU32(&x1036, &x1037, x992, 0xffffffff);
var x1038: u32 = undefined;
var x1039: u1 = undefined;
addcarryxU32(&x1038, &x1039, 0x0, x1035, x1032);
var x1040: u32 = undefined;
var x1041: u1 = undefined;
addcarryxU32(&x1040, &x1041, x1039, x1033, x1030);
var x1042: u32 = undefined;
var x1043: u1 = undefined;
addcarryxU32(&x1042, &x1043, x1041, x1031, x1028);
var x1044: u32 = undefined;
var x1045: u1 = undefined;
addcarryxU32(&x1044, &x1045, x1043, x1029, x1026);
var x1046: u32 = undefined;
var x1047: u1 = undefined;
addcarryxU32(&x1046, &x1047, x1045, x1027, x1024);
var x1048: u32 = undefined;
var x1049: u1 = undefined;
addcarryxU32(&x1048, &x1049, x1047, x1025, x1022);
var x1050: u32 = undefined;
var x1051: u1 = undefined;
addcarryxU32(&x1050, &x1051, x1049, x1023, x1020);
var x1052: u32 = undefined;
var x1053: u1 = undefined;
addcarryxU32(&x1052, &x1053, x1051, x1021, x1018);
const x1054 = (cast(u32, x1053) + x1019);
var x1055: u32 = undefined;
var x1056: u1 = undefined;
addcarryxU32(&x1055, &x1056, 0x0, x992, x1036);
var x1057: u32 = undefined;
var x1058: u1 = undefined;
addcarryxU32(&x1057, &x1058, x1056, x994, x1037);
var x1059: u32 = undefined;
var x1060: u1 = undefined;
addcarryxU32(&x1059, &x1060, x1058, x996, cast(u32, 0x0));
var x1061: u32 = undefined;
var x1062: u1 = undefined;
addcarryxU32(&x1061, &x1062, x1060, x998, x1034);
var x1063: u32 = undefined;
var x1064: u1 = undefined;
addcarryxU32(&x1063, &x1064, x1062, x1000, x1038);
var x1065: u32 = undefined;
var x1066: u1 = undefined;
addcarryxU32(&x1065, &x1066, x1064, x1002, x1040);
var x1067: u32 = undefined;
var x1068: u1 = undefined;
addcarryxU32(&x1067, &x1068, x1066, x1004, x1042);
var x1069: u32 = undefined;
var x1070: u1 = undefined;
addcarryxU32(&x1069, &x1070, x1068, x1006, x1044);
var x1071: u32 = undefined;
var x1072: u1 = undefined;
addcarryxU32(&x1071, &x1072, x1070, x1008, x1046);
var x1073: u32 = undefined;
var x1074: u1 = undefined;
addcarryxU32(&x1073, &x1074, x1072, x1010, x1048);
var x1075: u32 = undefined;
var x1076: u1 = undefined;
addcarryxU32(&x1075, &x1076, x1074, x1012, x1050);
var x1077: u32 = undefined;
var x1078: u1 = undefined;
addcarryxU32(&x1077, &x1078, x1076, x1014, x1052);
var x1079: u32 = undefined;
var x1080: u1 = undefined;
addcarryxU32(&x1079, &x1080, x1078, x1016, x1054);
const x1081 = (cast(u32, x1080) + cast(u32, x1017));
var x1082: u32 = undefined;
var x1083: u32 = undefined;
mulxU32(&x1082, &x1083, x8, (arg1[11]));
var x1084: u32 = undefined;
var x1085: u32 = undefined;
mulxU32(&x1084, &x1085, x8, (arg1[10]));
var x1086: u32 = undefined;
var x1087: u32 = undefined;
mulxU32(&x1086, &x1087, x8, (arg1[9]));
var x1088: u32 = undefined;
var x1089: u32 = undefined;
mulxU32(&x1088, &x1089, x8, (arg1[8]));
var x1090: u32 = undefined;
var x1091: u32 = undefined;
mulxU32(&x1090, &x1091, x8, (arg1[7]));
var x1092: u32 = undefined;
var x1093: u32 = undefined;
mulxU32(&x1092, &x1093, x8, (arg1[6]));
var x1094: u32 = undefined;
var x1095: u32 = undefined;
mulxU32(&x1094, &x1095, x8, (arg1[5]));
var x1096: u32 = undefined;
var x1097: u32 = undefined;
mulxU32(&x1096, &x1097, x8, (arg1[4]));
var x1098: u32 = undefined;
var x1099: u32 = undefined;
mulxU32(&x1098, &x1099, x8, (arg1[3]));
var x1100: u32 = undefined;
var x1101: u32 = undefined;
mulxU32(&x1100, &x1101, x8, (arg1[2]));
var x1102: u32 = undefined;
var x1103: u32 = undefined;
mulxU32(&x1102, &x1103, x8, (arg1[1]));
var x1104: u32 = undefined;
var x1105: u32 = undefined;
mulxU32(&x1104, &x1105, x8, (arg1[0]));
var x1106: u32 = undefined;
var x1107: u1 = undefined;
addcarryxU32(&x1106, &x1107, 0x0, x1105, x1102);
var x1108: u32 = undefined;
var x1109: u1 = undefined;
addcarryxU32(&x1108, &x1109, x1107, x1103, x1100);
var x1110: u32 = undefined;
var x1111: u1 = undefined;
addcarryxU32(&x1110, &x1111, x1109, x1101, x1098);
var x1112: u32 = undefined;
var x1113: u1 = undefined;
addcarryxU32(&x1112, &x1113, x1111, x1099, x1096);
var x1114: u32 = undefined;
var x1115: u1 = undefined;
addcarryxU32(&x1114, &x1115, x1113, x1097, x1094);
var x1116: u32 = undefined;
var x1117: u1 = undefined;
addcarryxU32(&x1116, &x1117, x1115, x1095, x1092);
var x1118: u32 = undefined;
var x1119: u1 = undefined;
addcarryxU32(&x1118, &x1119, x1117, x1093, x1090);
var x1120: u32 = undefined;
var x1121: u1 = undefined;
addcarryxU32(&x1120, &x1121, x1119, x1091, x1088);
var x1122: u32 = undefined;
var x1123: u1 = undefined;
addcarryxU32(&x1122, &x1123, x1121, x1089, x1086);
var x1124: u32 = undefined;
var x1125: u1 = undefined;
addcarryxU32(&x1124, &x1125, x1123, x1087, x1084);
var x1126: u32 = undefined;
var x1127: u1 = undefined;
addcarryxU32(&x1126, &x1127, x1125, x1085, x1082);
const x1128 = (cast(u32, x1127) + x1083);
var x1129: u32 = undefined;
var x1130: u1 = undefined;
addcarryxU32(&x1129, &x1130, 0x0, x1057, x1104);
var x1131: u32 = undefined;
var x1132: u1 = undefined;
addcarryxU32(&x1131, &x1132, x1130, x1059, x1106);
var x1133: u32 = undefined;
var x1134: u1 = undefined;
addcarryxU32(&x1133, &x1134, x1132, x1061, x1108);
var x1135: u32 = undefined;
var x1136: u1 = undefined;
addcarryxU32(&x1135, &x1136, x1134, x1063, x1110);
var x1137: u32 = undefined;
var x1138: u1 = undefined;
addcarryxU32(&x1137, &x1138, x1136, x1065, x1112);
var x1139: u32 = undefined;
var x1140: u1 = undefined;
addcarryxU32(&x1139, &x1140, x1138, x1067, x1114);
var x1141: u32 = undefined;
var x1142: u1 = undefined;
addcarryxU32(&x1141, &x1142, x1140, x1069, x1116);
var x1143: u32 = undefined;
var x1144: u1 = undefined;
addcarryxU32(&x1143, &x1144, x1142, x1071, x1118);
var x1145: u32 = undefined;
var x1146: u1 = undefined;
addcarryxU32(&x1145, &x1146, x1144, x1073, x1120);
var x1147: u32 = undefined;
var x1148: u1 = undefined;
addcarryxU32(&x1147, &x1148, x1146, x1075, x1122);
var x1149: u32 = undefined;
var x1150: u1 = undefined;
addcarryxU32(&x1149, &x1150, x1148, x1077, x1124);
var x1151: u32 = undefined;
var x1152: u1 = undefined;
addcarryxU32(&x1151, &x1152, x1150, x1079, x1126);
var x1153: u32 = undefined;
var x1154: u1 = undefined;
addcarryxU32(&x1153, &x1154, x1152, x1081, x1128);
var x1155: u32 = undefined;
var x1156: u32 = undefined;
mulxU32(&x1155, &x1156, x1129, 0xffffffff);
var x1157: u32 = undefined;
var x1158: u32 = undefined;
mulxU32(&x1157, &x1158, x1129, 0xffffffff);
var x1159: u32 = undefined;
var x1160: u32 = undefined;
mulxU32(&x1159, &x1160, x1129, 0xffffffff);
var x1161: u32 = undefined;
var x1162: u32 = undefined;
mulxU32(&x1161, &x1162, x1129, 0xffffffff);
var x1163: u32 = undefined;
var x1164: u32 = undefined;
mulxU32(&x1163, &x1164, x1129, 0xffffffff);
var x1165: u32 = undefined;
var x1166: u32 = undefined;
mulxU32(&x1165, &x1166, x1129, 0xffffffff);
var x1167: u32 = undefined;
var x1168: u32 = undefined;
mulxU32(&x1167, &x1168, x1129, 0xffffffff);
var x1169: u32 = undefined;
var x1170: u32 = undefined;
mulxU32(&x1169, &x1170, x1129, 0xfffffffe);
var x1171: u32 = undefined;
var x1172: u32 = undefined;
mulxU32(&x1171, &x1172, x1129, 0xffffffff);
var x1173: u32 = undefined;
var x1174: u32 = undefined;
mulxU32(&x1173, &x1174, x1129, 0xffffffff);
var x1175: u32 = undefined;
var x1176: u1 = undefined;
addcarryxU32(&x1175, &x1176, 0x0, x1172, x1169);
var x1177: u32 = undefined;
var x1178: u1 = undefined;
addcarryxU32(&x1177, &x1178, x1176, x1170, x1167);
var x1179: u32 = undefined;
var x1180: u1 = undefined;
addcarryxU32(&x1179, &x1180, x1178, x1168, x1165);
var x1181: u32 = undefined;
var x1182: u1 = undefined;
addcarryxU32(&x1181, &x1182, x1180, x1166, x1163);
var x1183: u32 = undefined;
var x1184: u1 = undefined;
addcarryxU32(&x1183, &x1184, x1182, x1164, x1161);
var x1185: u32 = undefined;
var x1186: u1 = undefined;
addcarryxU32(&x1185, &x1186, x1184, x1162, x1159);
var x1187: u32 = undefined;
var x1188: u1 = undefined;
addcarryxU32(&x1187, &x1188, x1186, x1160, x1157);
var x1189: u32 = undefined;
var x1190: u1 = undefined;
addcarryxU32(&x1189, &x1190, x1188, x1158, x1155);
const x1191 = (cast(u32, x1190) + x1156);
var x1192: u32 = undefined;
var x1193: u1 = undefined;
addcarryxU32(&x1192, &x1193, 0x0, x1129, x1173);
var x1194: u32 = undefined;
var x1195: u1 = undefined;
addcarryxU32(&x1194, &x1195, x1193, x1131, x1174);
var x1196: u32 = undefined;
var x1197: u1 = undefined;
addcarryxU32(&x1196, &x1197, x1195, x1133, cast(u32, 0x0));
var x1198: u32 = undefined;
var x1199: u1 = undefined;
addcarryxU32(&x1198, &x1199, x1197, x1135, x1171);
var x1200: u32 = undefined;
var x1201: u1 = undefined;
addcarryxU32(&x1200, &x1201, x1199, x1137, x1175);
var x1202: u32 = undefined;
var x1203: u1 = undefined;
addcarryxU32(&x1202, &x1203, x1201, x1139, x1177);
var x1204: u32 = undefined;
var x1205: u1 = undefined;
addcarryxU32(&x1204, &x1205, x1203, x1141, x1179);
var x1206: u32 = undefined;
var x1207: u1 = undefined;
addcarryxU32(&x1206, &x1207, x1205, x1143, x1181);
var x1208: u32 = undefined;
var x1209: u1 = undefined;
addcarryxU32(&x1208, &x1209, x1207, x1145, x1183);
var x1210: u32 = undefined;
var x1211: u1 = undefined;
addcarryxU32(&x1210, &x1211, x1209, x1147, x1185);
var x1212: u32 = undefined;
var x1213: u1 = undefined;
addcarryxU32(&x1212, &x1213, x1211, x1149, x1187);
var x1214: u32 = undefined;
var x1215: u1 = undefined;
addcarryxU32(&x1214, &x1215, x1213, x1151, x1189);
var x1216: u32 = undefined;
var x1217: u1 = undefined;
addcarryxU32(&x1216, &x1217, x1215, x1153, x1191);
const x1218 = (cast(u32, x1217) + cast(u32, x1154));
var x1219: u32 = undefined;
var x1220: u32 = undefined;
mulxU32(&x1219, &x1220, x9, (arg1[11]));
var x1221: u32 = undefined;
var x1222: u32 = undefined;
mulxU32(&x1221, &x1222, x9, (arg1[10]));
var x1223: u32 = undefined;
var x1224: u32 = undefined;
mulxU32(&x1223, &x1224, x9, (arg1[9]));
var x1225: u32 = undefined;
var x1226: u32 = undefined;
mulxU32(&x1225, &x1226, x9, (arg1[8]));
var x1227: u32 = undefined;
var x1228: u32 = undefined;
mulxU32(&x1227, &x1228, x9, (arg1[7]));
var x1229: u32 = undefined;
var x1230: u32 = undefined;
mulxU32(&x1229, &x1230, x9, (arg1[6]));
var x1231: u32 = undefined;
var x1232: u32 = undefined;
mulxU32(&x1231, &x1232, x9, (arg1[5]));
var x1233: u32 = undefined;
var x1234: u32 = undefined;
mulxU32(&x1233, &x1234, x9, (arg1[4]));
var x1235: u32 = undefined;
var x1236: u32 = undefined;
mulxU32(&x1235, &x1236, x9, (arg1[3]));
var x1237: u32 = undefined;
var x1238: u32 = undefined;
mulxU32(&x1237, &x1238, x9, (arg1[2]));
var x1239: u32 = undefined;
var x1240: u32 = undefined;
mulxU32(&x1239, &x1240, x9, (arg1[1]));
var x1241: u32 = undefined;
var x1242: u32 = undefined;
mulxU32(&x1241, &x1242, x9, (arg1[0]));
var x1243: u32 = undefined;
var x1244: u1 = undefined;
addcarryxU32(&x1243, &x1244, 0x0, x1242, x1239);
var x1245: u32 = undefined;
var x1246: u1 = undefined;
addcarryxU32(&x1245, &x1246, x1244, x1240, x1237);
var x1247: u32 = undefined;
var x1248: u1 = undefined;
addcarryxU32(&x1247, &x1248, x1246, x1238, x1235);
var x1249: u32 = undefined;
var x1250: u1 = undefined;
addcarryxU32(&x1249, &x1250, x1248, x1236, x1233);
var x1251: u32 = undefined;
var x1252: u1 = undefined;
addcarryxU32(&x1251, &x1252, x1250, x1234, x1231);
var x1253: u32 = undefined;
var x1254: u1 = undefined;
addcarryxU32(&x1253, &x1254, x1252, x1232, x1229);
var x1255: u32 = undefined;
var x1256: u1 = undefined;
addcarryxU32(&x1255, &x1256, x1254, x1230, x1227);
var x1257: u32 = undefined;
var x1258: u1 = undefined;
addcarryxU32(&x1257, &x1258, x1256, x1228, x1225);
var x1259: u32 = undefined;
var x1260: u1 = undefined;
addcarryxU32(&x1259, &x1260, x1258, x1226, x1223);
var x1261: u32 = undefined;
var x1262: u1 = undefined;
addcarryxU32(&x1261, &x1262, x1260, x1224, x1221);
var x1263: u32 = undefined;
var x1264: u1 = undefined;
addcarryxU32(&x1263, &x1264, x1262, x1222, x1219);
const x1265 = (cast(u32, x1264) + x1220);
var x1266: u32 = undefined;
var x1267: u1 = undefined;
addcarryxU32(&x1266, &x1267, 0x0, x1194, x1241);
var x1268: u32 = undefined;
var x1269: u1 = undefined;
addcarryxU32(&x1268, &x1269, x1267, x1196, x1243);
var x1270: u32 = undefined;
var x1271: u1 = undefined;
addcarryxU32(&x1270, &x1271, x1269, x1198, x1245);
var x1272: u32 = undefined;
var x1273: u1 = undefined;
addcarryxU32(&x1272, &x1273, x1271, x1200, x1247);
var x1274: u32 = undefined;
var x1275: u1 = undefined;
addcarryxU32(&x1274, &x1275, x1273, x1202, x1249);
var x1276: u32 = undefined;
var x1277: u1 = undefined;
addcarryxU32(&x1276, &x1277, x1275, x1204, x1251);
var x1278: u32 = undefined;
var x1279: u1 = undefined;
addcarryxU32(&x1278, &x1279, x1277, x1206, x1253);
var x1280: u32 = undefined;
var x1281: u1 = undefined;
addcarryxU32(&x1280, &x1281, x1279, x1208, x1255);
var x1282: u32 = undefined;
var x1283: u1 = undefined;
addcarryxU32(&x1282, &x1283, x1281, x1210, x1257);
var x1284: u32 = undefined;
var x1285: u1 = undefined;
addcarryxU32(&x1284, &x1285, x1283, x1212, x1259);
var x1286: u32 = undefined;
var x1287: u1 = undefined;
addcarryxU32(&x1286, &x1287, x1285, x1214, x1261);
var x1288: u32 = undefined;
var x1289: u1 = undefined;
addcarryxU32(&x1288, &x1289, x1287, x1216, x1263);
var x1290: u32 = undefined;
var x1291: u1 = undefined;
addcarryxU32(&x1290, &x1291, x1289, x1218, x1265);
var x1292: u32 = undefined;
var x1293: u32 = undefined;
mulxU32(&x1292, &x1293, x1266, 0xffffffff);
var x1294: u32 = undefined;
var x1295: u32 = undefined;
mulxU32(&x1294, &x1295, x1266, 0xffffffff);
var x1296: u32 = undefined;
var x1297: u32 = undefined;
mulxU32(&x1296, &x1297, x1266, 0xffffffff);
var x1298: u32 = undefined;
var x1299: u32 = undefined;
mulxU32(&x1298, &x1299, x1266, 0xffffffff);
var x1300: u32 = undefined;
var x1301: u32 = undefined;
mulxU32(&x1300, &x1301, x1266, 0xffffffff);
var x1302: u32 = undefined;
var x1303: u32 = undefined;
mulxU32(&x1302, &x1303, x1266, 0xffffffff);
var x1304: u32 = undefined;
var x1305: u32 = undefined;
mulxU32(&x1304, &x1305, x1266, 0xffffffff);
var x1306: u32 = undefined;
var x1307: u32 = undefined;
mulxU32(&x1306, &x1307, x1266, 0xfffffffe);
var x1308: u32 = undefined;
var x1309: u32 = undefined;
mulxU32(&x1308, &x1309, x1266, 0xffffffff);
var x1310: u32 = undefined;
var x1311: u32 = undefined;
mulxU32(&x1310, &x1311, x1266, 0xffffffff);
var x1312: u32 = undefined;
var x1313: u1 = undefined;
addcarryxU32(&x1312, &x1313, 0x0, x1309, x1306);
var x1314: u32 = undefined;
var x1315: u1 = undefined;
addcarryxU32(&x1314, &x1315, x1313, x1307, x1304);
var x1316: u32 = undefined;
var x1317: u1 = undefined;
addcarryxU32(&x1316, &x1317, x1315, x1305, x1302);
var x1318: u32 = undefined;
var x1319: u1 = undefined;
addcarryxU32(&x1318, &x1319, x1317, x1303, x1300);
var x1320: u32 = undefined;
var x1321: u1 = undefined;
addcarryxU32(&x1320, &x1321, x1319, x1301, x1298);
var x1322: u32 = undefined;
var x1323: u1 = undefined;
addcarryxU32(&x1322, &x1323, x1321, x1299, x1296);
var x1324: u32 = undefined;
var x1325: u1 = undefined;
addcarryxU32(&x1324, &x1325, x1323, x1297, x1294);
var x1326: u32 = undefined;
var x1327: u1 = undefined;
addcarryxU32(&x1326, &x1327, x1325, x1295, x1292);
const x1328 = (cast(u32, x1327) + x1293);
var x1329: u32 = undefined;
var x1330: u1 = undefined;
addcarryxU32(&x1329, &x1330, 0x0, x1266, x1310);
var x1331: u32 = undefined;
var x1332: u1 = undefined;
addcarryxU32(&x1331, &x1332, x1330, x1268, x1311);
var x1333: u32 = undefined;
var x1334: u1 = undefined;
addcarryxU32(&x1333, &x1334, x1332, x1270, cast(u32, 0x0));
var x1335: u32 = undefined;
var x1336: u1 = undefined;
addcarryxU32(&x1335, &x1336, x1334, x1272, x1308);
var x1337: u32 = undefined;
var x1338: u1 = undefined;
addcarryxU32(&x1337, &x1338, x1336, x1274, x1312);
var x1339: u32 = undefined;
var x1340: u1 = undefined;
addcarryxU32(&x1339, &x1340, x1338, x1276, x1314);
var x1341: u32 = undefined;
var x1342: u1 = undefined;
addcarryxU32(&x1341, &x1342, x1340, x1278, x1316);
var x1343: u32 = undefined;
var x1344: u1 = undefined;
addcarryxU32(&x1343, &x1344, x1342, x1280, x1318);
var x1345: u32 = undefined;
var x1346: u1 = undefined;
addcarryxU32(&x1345, &x1346, x1344, x1282, x1320);
var x1347: u32 = undefined;
var x1348: u1 = undefined;
addcarryxU32(&x1347, &x1348, x1346, x1284, x1322);
var x1349: u32 = undefined;
var x1350: u1 = undefined;
addcarryxU32(&x1349, &x1350, x1348, x1286, x1324);
var x1351: u32 = undefined;
var x1352: u1 = undefined;
addcarryxU32(&x1351, &x1352, x1350, x1288, x1326);
var x1353: u32 = undefined;
var x1354: u1 = undefined;
addcarryxU32(&x1353, &x1354, x1352, x1290, x1328);
const x1355 = (cast(u32, x1354) + cast(u32, x1291));
var x1356: u32 = undefined;
var x1357: u32 = undefined;
mulxU32(&x1356, &x1357, x10, (arg1[11]));
var x1358: u32 = undefined;
var x1359: u32 = undefined;
mulxU32(&x1358, &x1359, x10, (arg1[10]));
var x1360: u32 = undefined;
var x1361: u32 = undefined;
mulxU32(&x1360, &x1361, x10, (arg1[9]));
var x1362: u32 = undefined;
var x1363: u32 = undefined;
mulxU32(&x1362, &x1363, x10, (arg1[8]));
var x1364: u32 = undefined;
var x1365: u32 = undefined;
mulxU32(&x1364, &x1365, x10, (arg1[7]));
var x1366: u32 = undefined;
var x1367: u32 = undefined;
mulxU32(&x1366, &x1367, x10, (arg1[6]));
var x1368: u32 = undefined;
var x1369: u32 = undefined;
mulxU32(&x1368, &x1369, x10, (arg1[5]));
var x1370: u32 = undefined;
var x1371: u32 = undefined;
mulxU32(&x1370, &x1371, x10, (arg1[4]));
var x1372: u32 = undefined;
var x1373: u32 = undefined;
mulxU32(&x1372, &x1373, x10, (arg1[3]));
var x1374: u32 = undefined;
var x1375: u32 = undefined;
mulxU32(&x1374, &x1375, x10, (arg1[2]));
var x1376: u32 = undefined;
var x1377: u32 = undefined;
mulxU32(&x1376, &x1377, x10, (arg1[1]));
var x1378: u32 = undefined;
var x1379: u32 = undefined;
mulxU32(&x1378, &x1379, x10, (arg1[0]));
var x1380: u32 = undefined;
var x1381: u1 = undefined;
addcarryxU32(&x1380, &x1381, 0x0, x1379, x1376);
var x1382: u32 = undefined;
var x1383: u1 = undefined;
addcarryxU32(&x1382, &x1383, x1381, x1377, x1374);
var x1384: u32 = undefined;
var x1385: u1 = undefined;
addcarryxU32(&x1384, &x1385, x1383, x1375, x1372);
var x1386: u32 = undefined;
var x1387: u1 = undefined;
addcarryxU32(&x1386, &x1387, x1385, x1373, x1370);
var x1388: u32 = undefined;
var x1389: u1 = undefined;
addcarryxU32(&x1388, &x1389, x1387, x1371, x1368);
var x1390: u32 = undefined;
var x1391: u1 = undefined;
addcarryxU32(&x1390, &x1391, x1389, x1369, x1366);
var x1392: u32 = undefined;
var x1393: u1 = undefined;
addcarryxU32(&x1392, &x1393, x1391, x1367, x1364);
var x1394: u32 = undefined;
var x1395: u1 = undefined;
addcarryxU32(&x1394, &x1395, x1393, x1365, x1362);
var x1396: u32 = undefined;
var x1397: u1 = undefined;
addcarryxU32(&x1396, &x1397, x1395, x1363, x1360);
var x1398: u32 = undefined;
var x1399: u1 = undefined;
addcarryxU32(&x1398, &x1399, x1397, x1361, x1358);
var x1400: u32 = undefined;
var x1401: u1 = undefined;
addcarryxU32(&x1400, &x1401, x1399, x1359, x1356);
const x1402 = (cast(u32, x1401) + x1357);
var x1403: u32 = undefined;
var x1404: u1 = undefined;
addcarryxU32(&x1403, &x1404, 0x0, x1331, x1378);
var x1405: u32 = undefined;
var x1406: u1 = undefined;
addcarryxU32(&x1405, &x1406, x1404, x1333, x1380);
var x1407: u32 = undefined;
var x1408: u1 = undefined;
addcarryxU32(&x1407, &x1408, x1406, x1335, x1382);
var x1409: u32 = undefined;
var x1410: u1 = undefined;
addcarryxU32(&x1409, &x1410, x1408, x1337, x1384);
var x1411: u32 = undefined;
var x1412: u1 = undefined;
addcarryxU32(&x1411, &x1412, x1410, x1339, x1386);
var x1413: u32 = undefined;
var x1414: u1 = undefined;
addcarryxU32(&x1413, &x1414, x1412, x1341, x1388);
var x1415: u32 = undefined;
var x1416: u1 = undefined;
addcarryxU32(&x1415, &x1416, x1414, x1343, x1390);
var x1417: u32 = undefined;
var x1418: u1 = undefined;
addcarryxU32(&x1417, &x1418, x1416, x1345, x1392);
var x1419: u32 = undefined;
var x1420: u1 = undefined;
addcarryxU32(&x1419, &x1420, x1418, x1347, x1394);
var x1421: u32 = undefined;
var x1422: u1 = undefined;
addcarryxU32(&x1421, &x1422, x1420, x1349, x1396);
var x1423: u32 = undefined;
var x1424: u1 = undefined;
addcarryxU32(&x1423, &x1424, x1422, x1351, x1398);
var x1425: u32 = undefined;
var x1426: u1 = undefined;
addcarryxU32(&x1425, &x1426, x1424, x1353, x1400);
var x1427: u32 = undefined;
var x1428: u1 = undefined;
addcarryxU32(&x1427, &x1428, x1426, x1355, x1402);
var x1429: u32 = undefined;
var x1430: u32 = undefined;
mulxU32(&x1429, &x1430, x1403, 0xffffffff);
var x1431: u32 = undefined;
var x1432: u32 = undefined;
mulxU32(&x1431, &x1432, x1403, 0xffffffff);
var x1433: u32 = undefined;
var x1434: u32 = undefined;
mulxU32(&x1433, &x1434, x1403, 0xffffffff);
var x1435: u32 = undefined;
var x1436: u32 = undefined;
mulxU32(&x1435, &x1436, x1403, 0xffffffff);
var x1437: u32 = undefined;
var x1438: u32 = undefined;
mulxU32(&x1437, &x1438, x1403, 0xffffffff);
var x1439: u32 = undefined;
var x1440: u32 = undefined;
mulxU32(&x1439, &x1440, x1403, 0xffffffff);
var x1441: u32 = undefined;
var x1442: u32 = undefined;
mulxU32(&x1441, &x1442, x1403, 0xffffffff);
var x1443: u32 = undefined;
var x1444: u32 = undefined;
mulxU32(&x1443, &x1444, x1403, 0xfffffffe);
var x1445: u32 = undefined;
var x1446: u32 = undefined;
mulxU32(&x1445, &x1446, x1403, 0xffffffff);
var x1447: u32 = undefined;
var x1448: u32 = undefined;
mulxU32(&x1447, &x1448, x1403, 0xffffffff);
var x1449: u32 = undefined;
var x1450: u1 = undefined;
addcarryxU32(&x1449, &x1450, 0x0, x1446, x1443);
var x1451: u32 = undefined;
var x1452: u1 = undefined;
addcarryxU32(&x1451, &x1452, x1450, x1444, x1441);
var x1453: u32 = undefined;
var x1454: u1 = undefined;
addcarryxU32(&x1453, &x1454, x1452, x1442, x1439);
var x1455: u32 = undefined;
var x1456: u1 = undefined;
addcarryxU32(&x1455, &x1456, x1454, x1440, x1437);
var x1457: u32 = undefined;
var x1458: u1 = undefined;
addcarryxU32(&x1457, &x1458, x1456, x1438, x1435);
var x1459: u32 = undefined;
var x1460: u1 = undefined;
addcarryxU32(&x1459, &x1460, x1458, x1436, x1433);
var x1461: u32 = undefined;
var x1462: u1 = undefined;
addcarryxU32(&x1461, &x1462, x1460, x1434, x1431);
var x1463: u32 = undefined;
var x1464: u1 = undefined;
addcarryxU32(&x1463, &x1464, x1462, x1432, x1429);
const x1465 = (cast(u32, x1464) + x1430);
var x1466: u32 = undefined;
var x1467: u1 = undefined;
addcarryxU32(&x1466, &x1467, 0x0, x1403, x1447);
var x1468: u32 = undefined;
var x1469: u1 = undefined;
addcarryxU32(&x1468, &x1469, x1467, x1405, x1448);
var x1470: u32 = undefined;
var x1471: u1 = undefined;
addcarryxU32(&x1470, &x1471, x1469, x1407, cast(u32, 0x0));
var x1472: u32 = undefined;
var x1473: u1 = undefined;
addcarryxU32(&x1472, &x1473, x1471, x1409, x1445);
var x1474: u32 = undefined;
var x1475: u1 = undefined;
addcarryxU32(&x1474, &x1475, x1473, x1411, x1449);
var x1476: u32 = undefined;
var x1477: u1 = undefined;
addcarryxU32(&x1476, &x1477, x1475, x1413, x1451);
var x1478: u32 = undefined;
var x1479: u1 = undefined;
addcarryxU32(&x1478, &x1479, x1477, x1415, x1453);
var x1480: u32 = undefined;
var x1481: u1 = undefined;
addcarryxU32(&x1480, &x1481, x1479, x1417, x1455);
var x1482: u32 = undefined;
var x1483: u1 = undefined;
addcarryxU32(&x1482, &x1483, x1481, x1419, x1457);
var x1484: u32 = undefined;
var x1485: u1 = undefined;
addcarryxU32(&x1484, &x1485, x1483, x1421, x1459);
var x1486: u32 = undefined;
var x1487: u1 = undefined;
addcarryxU32(&x1486, &x1487, x1485, x1423, x1461);
var x1488: u32 = undefined;
var x1489: u1 = undefined;
addcarryxU32(&x1488, &x1489, x1487, x1425, x1463);
var x1490: u32 = undefined;
var x1491: u1 = undefined;
addcarryxU32(&x1490, &x1491, x1489, x1427, x1465);
const x1492 = (cast(u32, x1491) + cast(u32, x1428));
var x1493: u32 = undefined;
var x1494: u32 = undefined;
mulxU32(&x1493, &x1494, x11, (arg1[11]));
var x1495: u32 = undefined;
var x1496: u32 = undefined;
mulxU32(&x1495, &x1496, x11, (arg1[10]));
var x1497: u32 = undefined;
var x1498: u32 = undefined;
mulxU32(&x1497, &x1498, x11, (arg1[9]));
var x1499: u32 = undefined;
var x1500: u32 = undefined;
mulxU32(&x1499, &x1500, x11, (arg1[8]));
var x1501: u32 = undefined;
var x1502: u32 = undefined;
mulxU32(&x1501, &x1502, x11, (arg1[7]));
var x1503: u32 = undefined;
var x1504: u32 = undefined;
mulxU32(&x1503, &x1504, x11, (arg1[6]));
var x1505: u32 = undefined;
var x1506: u32 = undefined;
mulxU32(&x1505, &x1506, x11, (arg1[5]));
var x1507: u32 = undefined;
var x1508: u32 = undefined;
mulxU32(&x1507, &x1508, x11, (arg1[4]));
var x1509: u32 = undefined;
var x1510: u32 = undefined;
mulxU32(&x1509, &x1510, x11, (arg1[3]));
var x1511: u32 = undefined;
var x1512: u32 = undefined;
mulxU32(&x1511, &x1512, x11, (arg1[2]));
var x1513: u32 = undefined;
var x1514: u32 = undefined;
mulxU32(&x1513, &x1514, x11, (arg1[1]));
var x1515: u32 = undefined;
var x1516: u32 = undefined;
mulxU32(&x1515, &x1516, x11, (arg1[0]));
var x1517: u32 = undefined;
var x1518: u1 = undefined;
addcarryxU32(&x1517, &x1518, 0x0, x1516, x1513);
var x1519: u32 = undefined;
var x1520: u1 = undefined;
addcarryxU32(&x1519, &x1520, x1518, x1514, x1511);
var x1521: u32 = undefined;
var x1522: u1 = undefined;
addcarryxU32(&x1521, &x1522, x1520, x1512, x1509);
var x1523: u32 = undefined;
var x1524: u1 = undefined;
addcarryxU32(&x1523, &x1524, x1522, x1510, x1507);
var x1525: u32 = undefined;
var x1526: u1 = undefined;
addcarryxU32(&x1525, &x1526, x1524, x1508, x1505);
var x1527: u32 = undefined;
var x1528: u1 = undefined;
addcarryxU32(&x1527, &x1528, x1526, x1506, x1503);
var x1529: u32 = undefined;
var x1530: u1 = undefined;
addcarryxU32(&x1529, &x1530, x1528, x1504, x1501);
var x1531: u32 = undefined;
var x1532: u1 = undefined;
addcarryxU32(&x1531, &x1532, x1530, x1502, x1499);
var x1533: u32 = undefined;
var x1534: u1 = undefined;
addcarryxU32(&x1533, &x1534, x1532, x1500, x1497);
var x1535: u32 = undefined;
var x1536: u1 = undefined;
addcarryxU32(&x1535, &x1536, x1534, x1498, x1495);
var x1537: u32 = undefined;
var x1538: u1 = undefined;
addcarryxU32(&x1537, &x1538, x1536, x1496, x1493);
const x1539 = (cast(u32, x1538) + x1494);
var x1540: u32 = undefined;
var x1541: u1 = undefined;
addcarryxU32(&x1540, &x1541, 0x0, x1468, x1515);
var x1542: u32 = undefined;
var x1543: u1 = undefined;
addcarryxU32(&x1542, &x1543, x1541, x1470, x1517);
var x1544: u32 = undefined;
var x1545: u1 = undefined;
addcarryxU32(&x1544, &x1545, x1543, x1472, x1519);
var x1546: u32 = undefined;
var x1547: u1 = undefined;
addcarryxU32(&x1546, &x1547, x1545, x1474, x1521);
var x1548: u32 = undefined;
var x1549: u1 = undefined;
addcarryxU32(&x1548, &x1549, x1547, x1476, x1523);
var x1550: u32 = undefined;
var x1551: u1 = undefined;
addcarryxU32(&x1550, &x1551, x1549, x1478, x1525);
var x1552: u32 = undefined;
var x1553: u1 = undefined;
addcarryxU32(&x1552, &x1553, x1551, x1480, x1527);
var x1554: u32 = undefined;
var x1555: u1 = undefined;
addcarryxU32(&x1554, &x1555, x1553, x1482, x1529);
var x1556: u32 = undefined;
var x1557: u1 = undefined;
addcarryxU32(&x1556, &x1557, x1555, x1484, x1531);
var x1558: u32 = undefined;
var x1559: u1 = undefined;
addcarryxU32(&x1558, &x1559, x1557, x1486, x1533);
var x1560: u32 = undefined;
var x1561: u1 = undefined;
addcarryxU32(&x1560, &x1561, x1559, x1488, x1535);
var x1562: u32 = undefined;
var x1563: u1 = undefined;
addcarryxU32(&x1562, &x1563, x1561, x1490, x1537);
var x1564: u32 = undefined;
var x1565: u1 = undefined;
addcarryxU32(&x1564, &x1565, x1563, x1492, x1539);
var x1566: u32 = undefined;
var x1567: u32 = undefined;
mulxU32(&x1566, &x1567, x1540, 0xffffffff);
var x1568: u32 = undefined;
var x1569: u32 = undefined;
mulxU32(&x1568, &x1569, x1540, 0xffffffff);
var x1570: u32 = undefined;
var x1571: u32 = undefined;
mulxU32(&x1570, &x1571, x1540, 0xffffffff);
var x1572: u32 = undefined;
var x1573: u32 = undefined;
mulxU32(&x1572, &x1573, x1540, 0xffffffff);
var x1574: u32 = undefined;
var x1575: u32 = undefined;
mulxU32(&x1574, &x1575, x1540, 0xffffffff);
var x1576: u32 = undefined;
var x1577: u32 = undefined;
mulxU32(&x1576, &x1577, x1540, 0xffffffff);
var x1578: u32 = undefined;
var x1579: u32 = undefined;
mulxU32(&x1578, &x1579, x1540, 0xffffffff);
var x1580: u32 = undefined;
var x1581: u32 = undefined;
mulxU32(&x1580, &x1581, x1540, 0xfffffffe);
var x1582: u32 = undefined;
var x1583: u32 = undefined;
mulxU32(&x1582, &x1583, x1540, 0xffffffff);
var x1584: u32 = undefined;
var x1585: u32 = undefined;
mulxU32(&x1584, &x1585, x1540, 0xffffffff);
var x1586: u32 = undefined;
var x1587: u1 = undefined;
addcarryxU32(&x1586, &x1587, 0x0, x1583, x1580);
var x1588: u32 = undefined;
var x1589: u1 = undefined;
addcarryxU32(&x1588, &x1589, x1587, x1581, x1578);
var x1590: u32 = undefined;
var x1591: u1 = undefined;
addcarryxU32(&x1590, &x1591, x1589, x1579, x1576);
var x1592: u32 = undefined;
var x1593: u1 = undefined;
addcarryxU32(&x1592, &x1593, x1591, x1577, x1574);
var x1594: u32 = undefined;
var x1595: u1 = undefined;
addcarryxU32(&x1594, &x1595, x1593, x1575, x1572);
var x1596: u32 = undefined;
var x1597: u1 = undefined;
addcarryxU32(&x1596, &x1597, x1595, x1573, x1570);
var x1598: u32 = undefined;
var x1599: u1 = undefined;
addcarryxU32(&x1598, &x1599, x1597, x1571, x1568);
var x1600: u32 = undefined;
var x1601: u1 = undefined;
addcarryxU32(&x1600, &x1601, x1599, x1569, x1566);
const x1602 = (cast(u32, x1601) + x1567);
var x1603: u32 = undefined;
var x1604: u1 = undefined;
addcarryxU32(&x1603, &x1604, 0x0, x1540, x1584);
var x1605: u32 = undefined;
var x1606: u1 = undefined;
addcarryxU32(&x1605, &x1606, x1604, x1542, x1585);
var x1607: u32 = undefined;
var x1608: u1 = undefined;
addcarryxU32(&x1607, &x1608, x1606, x1544, cast(u32, 0x0));
var x1609: u32 = undefined;
var x1610: u1 = undefined;
addcarryxU32(&x1609, &x1610, x1608, x1546, x1582);
var x1611: u32 = undefined;
var x1612: u1 = undefined;
addcarryxU32(&x1611, &x1612, x1610, x1548, x1586);
var x1613: u32 = undefined;
var x1614: u1 = undefined;
addcarryxU32(&x1613, &x1614, x1612, x1550, x1588);
var x1615: u32 = undefined;
var x1616: u1 = undefined;
addcarryxU32(&x1615, &x1616, x1614, x1552, x1590);
var x1617: u32 = undefined;
var x1618: u1 = undefined;
addcarryxU32(&x1617, &x1618, x1616, x1554, x1592);
var x1619: u32 = undefined;
var x1620: u1 = undefined;
addcarryxU32(&x1619, &x1620, x1618, x1556, x1594);
var x1621: u32 = undefined;
var x1622: u1 = undefined;
addcarryxU32(&x1621, &x1622, x1620, x1558, x1596);
var x1623: u32 = undefined;
var x1624: u1 = undefined;
addcarryxU32(&x1623, &x1624, x1622, x1560, x1598);
var x1625: u32 = undefined;
var x1626: u1 = undefined;
addcarryxU32(&x1625, &x1626, x1624, x1562, x1600);
var x1627: u32 = undefined;
var x1628: u1 = undefined;
addcarryxU32(&x1627, &x1628, x1626, x1564, x1602);
const x1629 = (cast(u32, x1628) + cast(u32, x1565));
var x1630: u32 = undefined;
var x1631: u1 = undefined;
subborrowxU32(&x1630, &x1631, 0x0, x1605, 0xffffffff);
var x1632: u32 = undefined;
var x1633: u1 = undefined;
subborrowxU32(&x1632, &x1633, x1631, x1607, cast(u32, 0x0));
var x1634: u32 = undefined;
var x1635: u1 = undefined;
subborrowxU32(&x1634, &x1635, x1633, x1609, cast(u32, 0x0));
var x1636: u32 = undefined;
var x1637: u1 = undefined;
subborrowxU32(&x1636, &x1637, x1635, x1611, 0xffffffff);
var x1638: u32 = undefined;
var x1639: u1 = undefined;
subborrowxU32(&x1638, &x1639, x1637, x1613, 0xfffffffe);
var x1640: u32 = undefined;
var x1641: u1 = undefined;
subborrowxU32(&x1640, &x1641, x1639, x1615, 0xffffffff);
var x1642: u32 = undefined;
var x1643: u1 = undefined;
subborrowxU32(&x1642, &x1643, x1641, x1617, 0xffffffff);
var x1644: u32 = undefined;
var x1645: u1 = undefined;
subborrowxU32(&x1644, &x1645, x1643, x1619, 0xffffffff);
var x1646: u32 = undefined;
var x1647: u1 = undefined;
subborrowxU32(&x1646, &x1647, x1645, x1621, 0xffffffff);
var x1648: u32 = undefined;
var x1649: u1 = undefined;
subborrowxU32(&x1648, &x1649, x1647, x1623, 0xffffffff);
var x1650: u32 = undefined;
var x1651: u1 = undefined;
subborrowxU32(&x1650, &x1651, x1649, x1625, 0xffffffff);
var x1652: u32 = undefined;
var x1653: u1 = undefined;
subborrowxU32(&x1652, &x1653, x1651, x1627, 0xffffffff);
var x1654: u32 = undefined;
var x1655: u1 = undefined;
subborrowxU32(&x1654, &x1655, x1653, x1629, cast(u32, 0x0));
var x1656: u32 = undefined;
cmovznzU32(&x1656, x1655, x1630, x1605);
var x1657: u32 = undefined;
cmovznzU32(&x1657, x1655, x1632, x1607);
var x1658: u32 = undefined;
cmovznzU32(&x1658, x1655, x1634, x1609);
var x1659: u32 = undefined;
cmovznzU32(&x1659, x1655, x1636, x1611);
var x1660: u32 = undefined;
cmovznzU32(&x1660, x1655, x1638, x1613);
var x1661: u32 = undefined;
cmovznzU32(&x1661, x1655, x1640, x1615);
var x1662: u32 = undefined;
cmovznzU32(&x1662, x1655, x1642, x1617);
var x1663: u32 = undefined;
cmovznzU32(&x1663, x1655, x1644, x1619);
var x1664: u32 = undefined;
cmovznzU32(&x1664, x1655, x1646, x1621);
var x1665: u32 = undefined;
cmovznzU32(&x1665, x1655, x1648, x1623);
var x1666: u32 = undefined;
cmovznzU32(&x1666, x1655, x1650, x1625);
var x1667: u32 = undefined;
cmovznzU32(&x1667, x1655, x1652, x1627);
out1[0] = x1656;
out1[1] = x1657;
out1[2] = x1658;
out1[3] = x1659;
out1[4] = x1660;
out1[5] = x1661;
out1[6] = x1662;
out1[7] = x1663;
out1[8] = x1664;
out1[9] = x1665;
out1[10] = x1666;
out1[11] = x1667;
}
/// The function add adds two field elements in the Montgomery domain.
///
/// Preconditions:
/// 0 ≤ eval arg1 < m
/// 0 ≤ eval arg2 < m
/// Postconditions:
/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m
/// 0 ≤ eval out1 < m
///
pub fn add(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement, arg2: MontgomeryDomainFieldElement) void {
@setRuntimeSafety(mode == .Debug);
var x1: u32 = undefined;
var x2: u1 = undefined;
addcarryxU32(&x1, &x2, 0x0, (arg1[0]), (arg2[0]));
var x3: u32 = undefined;
var x4: u1 = undefined;
addcarryxU32(&x3, &x4, x2, (arg1[1]), (arg2[1]));
var x5: u32 = undefined;
var x6: u1 = undefined;
addcarryxU32(&x5, &x6, x4, (arg1[2]), (arg2[2]));
var x7: u32 = undefined;
var x8: u1 = undefined;
addcarryxU32(&x7, &x8, x6, (arg1[3]), (arg2[3]));
var x9: u32 = undefined;
var x10: u1 = undefined;
addcarryxU32(&x9, &x10, x8, (arg1[4]), (arg2[4]));
var x11: u32 = undefined;
var x12: u1 = undefined;
addcarryxU32(&x11, &x12, x10, (arg1[5]), (arg2[5]));
var x13: u32 = undefined;
var x14: u1 = undefined;
addcarryxU32(&x13, &x14, x12, (arg1[6]), (arg2[6]));
var x15: u32 = undefined;
var x16: u1 = undefined;
addcarryxU32(&x15, &x16, x14, (arg1[7]), (arg2[7]));
var x17: u32 = undefined;
var x18: u1 = undefined;
addcarryxU32(&x17, &x18, x16, (arg1[8]), (arg2[8]));
var x19: u32 = undefined;
var x20: u1 = undefined;
addcarryxU32(&x19, &x20, x18, (arg1[9]), (arg2[9]));
var x21: u32 = undefined;
var x22: u1 = undefined;
addcarryxU32(&x21, &x22, x20, (arg1[10]), (arg2[10]));
var x23: u32 = undefined;
var x24: u1 = undefined;
addcarryxU32(&x23, &x24, x22, (arg1[11]), (arg2[11]));
var x25: u32 = undefined;
var x26: u1 = undefined;
subborrowxU32(&x25, &x26, 0x0, x1, 0xffffffff);
var x27: u32 = undefined;
var x28: u1 = undefined;
subborrowxU32(&x27, &x28, x26, x3, cast(u32, 0x0));
var x29: u32 = undefined;
var x30: u1 = undefined;
subborrowxU32(&x29, &x30, x28, x5, cast(u32, 0x0));
var x31: u32 = undefined;
var x32: u1 = undefined;
subborrowxU32(&x31, &x32, x30, x7, 0xffffffff);
var x33: u32 = undefined;
var x34: u1 = undefined;
subborrowxU32(&x33, &x34, x32, x9, 0xfffffffe);
var x35: u32 = undefined;
var x36: u1 = undefined;
subborrowxU32(&x35, &x36, x34, x11, 0xffffffff);
var x37: u32 = undefined;
var x38: u1 = undefined;
subborrowxU32(&x37, &x38, x36, x13, 0xffffffff);
var x39: u32 = undefined;
var x40: u1 = undefined;
subborrowxU32(&x39, &x40, x38, x15, 0xffffffff);
var x41: u32 = undefined;
var x42: u1 = undefined;
subborrowxU32(&x41, &x42, x40, x17, 0xffffffff);
var x43: u32 = undefined;
var x44: u1 = undefined;
subborrowxU32(&x43, &x44, x42, x19, 0xffffffff);
var x45: u32 = undefined;
var x46: u1 = undefined;
subborrowxU32(&x45, &x46, x44, x21, 0xffffffff);
var x47: u32 = undefined;
var x48: u1 = undefined;
subborrowxU32(&x47, &x48, x46, x23, 0xffffffff);
var x49: u32 = undefined;
var x50: u1 = undefined;
subborrowxU32(&x49, &x50, x48, cast(u32, x24), cast(u32, 0x0));
var x51: u32 = undefined;
cmovznzU32(&x51, x50, x25, x1);
var x52: u32 = undefined;
cmovznzU32(&x52, x50, x27, x3);
var x53: u32 = undefined;
cmovznzU32(&x53, x50, x29, x5);
var x54: u32 = undefined;
cmovznzU32(&x54, x50, x31, x7);
var x55: u32 = undefined;
cmovznzU32(&x55, x50, x33, x9);
var x56: u32 = undefined;
cmovznzU32(&x56, x50, x35, x11);
var x57: u32 = undefined;
cmovznzU32(&x57, x50, x37, x13);
var x58: u32 = undefined;
cmovznzU32(&x58, x50, x39, x15);
var x59: u32 = undefined;
cmovznzU32(&x59, x50, x41, x17);
var x60: u32 = undefined;
cmovznzU32(&x60, x50, x43, x19);
var x61: u32 = undefined;
cmovznzU32(&x61, x50, x45, x21);
var x62: u32 = undefined;
cmovznzU32(&x62, x50, x47, x23);
out1[0] = x51;
out1[1] = x52;
out1[2] = x53;
out1[3] = x54;
out1[4] = x55;
out1[5] = x56;
out1[6] = x57;
out1[7] = x58;
out1[8] = x59;
out1[9] = x60;
out1[10] = x61;
out1[11] = x62;
}
/// The function sub subtracts two field elements in the Montgomery domain.
///
/// Preconditions:
/// 0 ≤ eval arg1 < m
/// 0 ≤ eval arg2 < m
/// Postconditions:
/// eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m
/// 0 ≤ eval out1 < m
///
pub fn sub(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement, arg2: MontgomeryDomainFieldElement) void {
@setRuntimeSafety(mode == .Debug);
var x1: u32 = undefined;
var x2: u1 = undefined;
subborrowxU32(&x1, &x2, 0x0, (arg1[0]), (arg2[0]));
var x3: u32 = undefined;
var x4: u1 = undefined;
subborrowxU32(&x3, &x4, x2, (arg1[1]), (arg2[1]));
var x5: u32 = undefined;
var x6: u1 = undefined;
subborrowxU32(&x5, &x6, x4, (arg1[2]), (arg2[2]));
var x7: u32 = undefined;
var x8: u1 = undefined;
subborrowxU32(&x7, &x8, x6, (arg1[3]), (arg2[3]));
var x9: u32 = undefined;
var x10: u1 = undefined;
subborrowxU32(&x9, &x10, x8, (arg1[4]), (arg2[4]));
var x11: u32 = undefined;
var x12: u1 = undefined;
subborrowxU32(&x11, &x12, x10, (arg1[5]), (arg2[5]));
var x13: u32 = undefined;
var x14: u1 = undefined;
subborrowxU32(&x13, &x14, x12, (arg1[6]), (arg2[6]));
var x15: u32 = undefined;
var x16: u1 = undefined;
subborrowxU32(&x15, &x16, x14, (arg1[7]), (arg2[7]));
var x17: u32 = undefined;
var x18: u1 = undefined;
subborrowxU32(&x17, &x18, x16, (arg1[8]), (arg2[8]));
var x19: u32 = undefined;
var x20: u1 = undefined;
subborrowxU32(&x19, &x20, x18, (arg1[9]), (arg2[9]));
var x21: u32 = undefined;
var x22: u1 = undefined;
subborrowxU32(&x21, &x22, x20, (arg1[10]), (arg2[10]));
var x23: u32 = undefined;
var x24: u1 = undefined;
subborrowxU32(&x23, &x24, x22, (arg1[11]), (arg2[11]));
var x25: u32 = undefined;
cmovznzU32(&x25, x24, cast(u32, 0x0), 0xffffffff);
var x26: u32 = undefined;
var x27: u1 = undefined;
addcarryxU32(&x26, &x27, 0x0, x1, x25);
var x28: u32 = undefined;
var x29: u1 = undefined;
addcarryxU32(&x28, &x29, x27, x3, cast(u32, 0x0));
var x30: u32 = undefined;
var x31: u1 = undefined;
addcarryxU32(&x30, &x31, x29, x5, cast(u32, 0x0));
var x32: u32 = undefined;
var x33: u1 = undefined;
addcarryxU32(&x32, &x33, x31, x7, x25);
var x34: u32 = undefined;
var x35: u1 = undefined;
addcarryxU32(&x34, &x35, x33, x9, (x25 & 0xfffffffe));
var x36: u32 = undefined;
var x37: u1 = undefined;
addcarryxU32(&x36, &x37, x35, x11, x25);
var x38: u32 = undefined;
var x39: u1 = undefined;
addcarryxU32(&x38, &x39, x37, x13, x25);
var x40: u32 = undefined;
var x41: u1 = undefined;
addcarryxU32(&x40, &x41, x39, x15, x25);
var x42: u32 = undefined;
var x43: u1 = undefined;
addcarryxU32(&x42, &x43, x41, x17, x25);
var x44: u32 = undefined;
var x45: u1 = undefined;
addcarryxU32(&x44, &x45, x43, x19, x25);
var x46: u32 = undefined;
var x47: u1 = undefined;
addcarryxU32(&x46, &x47, x45, x21, x25);
var x48: u32 = undefined;
var x49: u1 = undefined;
addcarryxU32(&x48, &x49, x47, x23, x25);
out1[0] = x26;
out1[1] = x28;
out1[2] = x30;
out1[3] = x32;
out1[4] = x34;
out1[5] = x36;
out1[6] = x38;
out1[7] = x40;
out1[8] = x42;
out1[9] = x44;
out1[10] = x46;
out1[11] = x48;
}
/// The function opp negates a field element in the Montgomery domain.
///
/// Preconditions:
/// 0 ≤ eval arg1 < m
/// Postconditions:
/// eval (from_montgomery out1) mod m = -eval (from_montgomery arg1) mod m
/// 0 ≤ eval out1 < m
///
pub fn opp(out1: *MontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement) void {
@setRuntimeSafety(mode == .Debug);
var x1: u32 = undefined;
var x2: u1 = undefined;
subborrowxU32(&x1, &x2, 0x0, cast(u32, 0x0), (arg1[0]));
var x3: u32 = undefined;
var x4: u1 = undefined;
subborrowxU32(&x3, &x4, x2, cast(u32, 0x0), (arg1[1]));
var x5: u32 = undefined;
var x6: u1 = undefined;
subborrowxU32(&x5, &x6, x4, cast(u32, 0x0), (arg1[2]));
var x7: u32 = undefined;
var x8: u1 = undefined;
subborrowxU32(&x7, &x8, x6, cast(u32, 0x0), (arg1[3]));
var x9: u32 = undefined;
var x10: u1 = undefined;
subborrowxU32(&x9, &x10, x8, cast(u32, 0x0), (arg1[4]));
var x11: u32 = undefined;
var x12: u1 = undefined;
subborrowxU32(&x11, &x12, x10, cast(u32, 0x0), (arg1[5]));
var x13: u32 = undefined;
var x14: u1 = undefined;
subborrowxU32(&x13, &x14, x12, cast(u32, 0x0), (arg1[6]));
var x15: u32 = undefined;
var x16: u1 = undefined;
subborrowxU32(&x15, &x16, x14, cast(u32, 0x0), (arg1[7]));
var x17: u32 = undefined;
var x18: u1 = undefined;
subborrowxU32(&x17, &x18, x16, cast(u32, 0x0), (arg1[8]));
var x19: u32 = undefined;
var x20: u1 = undefined;
subborrowxU32(&x19, &x20, x18, cast(u32, 0x0), (arg1[9]));
var x21: u32 = undefined;
var x22: u1 = undefined;
subborrowxU32(&x21, &x22, x20, cast(u32, 0x0), (arg1[10]));
var x23: u32 = undefined;
var x24: u1 = undefined;
subborrowxU32(&x23, &x24, x22, cast(u32, 0x0), (arg1[11]));
var x25: u32 = undefined;
cmovznzU32(&x25, x24, cast(u32, 0x0), 0xffffffff);
var x26: u32 = undefined;
var x27: u1 = undefined;
addcarryxU32(&x26, &x27, 0x0, x1, x25);
var x28: u32 = undefined;
var x29: u1 = undefined;
addcarryxU32(&x28, &x29, x27, x3, cast(u32, 0x0));
var x30: u32 = undefined;
var x31: u1 = undefined;
addcarryxU32(&x30, &x31, x29, x5, cast(u32, 0x0));
var x32: u32 = undefined;
var x33: u1 = undefined;
addcarryxU32(&x32, &x33, x31, x7, x25);
var x34: u32 = undefined;
var x35: u1 = undefined;
addcarryxU32(&x34, &x35, x33, x9, (x25 & 0xfffffffe));
var x36: u32 = undefined;
var x37: u1 = undefined;
addcarryxU32(&x36, &x37, x35, x11, x25);
var x38: u32 = undefined;
var x39: u1 = undefined;
addcarryxU32(&x38, &x39, x37, x13, x25);
var x40: u32 = undefined;
var x41: u1 = undefined;
addcarryxU32(&x40, &x41, x39, x15, x25);
var x42: u32 = undefined;
var x43: u1 = undefined;
addcarryxU32(&x42, &x43, x41, x17, x25);
var x44: u32 = undefined;
var x45: u1 = undefined;
addcarryxU32(&x44, &x45, x43, x19, x25);
var x46: u32 = undefined;
var x47: u1 = undefined;
addcarryxU32(&x46, &x47, x45, x21, x25);
var x48: u32 = undefined;
var x49: u1 = undefined;
addcarryxU32(&x48, &x49, x47, x23, x25);
out1[0] = x26;
out1[1] = x28;
out1[2] = x30;
out1[3] = x32;
out1[4] = x34;
out1[5] = x36;
out1[6] = x38;
out1[7] = x40;
out1[8] = x42;
out1[9] = x44;
out1[10] = x46;
out1[11] = x48;
}
/// The function fromMontgomery translates a field element out of the Montgomery domain.
///
/// Preconditions:
/// 0 ≤ eval arg1 < m
/// Postconditions:
/// eval out1 mod m = (eval arg1 * ((2^32)⁻¹ mod m)^12) mod m
/// 0 ≤ eval out1 < m
///
pub fn fromMontgomery(out1: *NonMontgomeryDomainFieldElement, arg1: MontgomeryDomainFieldElement) void {
@setRuntimeSafety(mode == .Debug);
const x1 = (arg1[0]);
var x2: u32 = undefined;
var x3: u32 = undefined;
mulxU32(&x2, &x3, x1, 0xffffffff);
var x4: u32 = undefined;
var x5: u32 = undefined;
mulxU32(&x4, &x5, x1, 0xffffffff);
var x6: u32 = undefined;
var x7: u32 = undefined;
mulxU32(&x6, &x7, x1, 0xffffffff);
var x8: u32 = undefined;
var x9: u32 = undefined;
mulxU32(&x8, &x9, x1, 0xffffffff);
var x10: u32 = undefined;
var x11: u32 = undefined;
mulxU32(&x10, &x11, x1, 0xffffffff);
var x12: u32 = undefined;
var x13: u32 = undefined;
mulxU32(&x12, &x13, x1, 0xffffffff);
var x14: u32 = undefined;
var x15: u32 = undefined;
mulxU32(&x14, &x15, x1, 0xffffffff);
var x16: u32 = undefined;
var x17: u32 = undefined;
mulxU32(&x16, &x17, x1, 0xfffffffe);
var x18: u32 = undefined;
var x19: u32 = undefined;
mulxU32(&x18, &x19, x1, 0xffffffff);
var x20: u32 = undefined;
var x21: u32 = undefined;
mulxU32(&x20, &x21, x1, 0xffffffff);
var x22: u32 = undefined;
var x23: u1 = undefined;
addcarryxU32(&x22, &x23, 0x0, x19, x16);
var x24: u32 = undefined;
var x25: u1 = undefined;
addcarryxU32(&x24, &x25, x23, x17, x14);
var x26: u32 = undefined;
var x27: u1 = undefined;
addcarryxU32(&x26, &x27, x25, x15, x12);
var x28: u32 = undefined;
var x29: u1 = undefined;
addcarryxU32(&x28, &x29, x27, x13, x10);
var x30: u32 = undefined;
var x31: u1 = undefined;
addcarryxU32(&x30, &x31, x29, x11, x8);
var x32: u32 = undefined;
var x33: u1 = undefined;
addcarryxU32(&x32, &x33, x31, x9, x6);
var x34: u32 = undefined;
var x35: u1 = undefined;
addcarryxU32(&x34, &x35, x33, x7, x4);
var x36: u32 = undefined;
var x37: u1 = undefined;
addcarryxU32(&x36, &x37, x35, x5, x2);
var x38: u32 = undefined;
var x39: u1 = undefined;
addcarryxU32(&x38, &x39, 0x0, x1, x20);
var x40: u32 = undefined;
var x41: u1 = undefined;
addcarryxU32(&x40, &x41, 0x0, (cast(u32, x39) + x21), (arg1[1]));
var x42: u32 = undefined;
var x43: u32 = undefined;
mulxU32(&x42, &x43, x40, 0xffffffff);
var x44: u32 = undefined;
var x45: u32 = undefined;
mulxU32(&x44, &x45, x40, 0xffffffff);
var x46: u32 = undefined;
var x47: u32 = undefined;
mulxU32(&x46, &x47, x40, 0xffffffff);
var x48: u32 = undefined;
var x49: u32 = undefined;
mulxU32(&x48, &x49, x40, 0xffffffff);
var x50: u32 = undefined;
var x51: u32 = undefined;
mulxU32(&x50, &x51, x40, 0xffffffff);
var x52: u32 = undefined;
var x53: u32 = undefined;
mulxU32(&x52, &x53, x40, 0xffffffff);
var x54: u32 = undefined;
var x55: u32 = undefined;
mulxU32(&x54, &x55, x40, 0xffffffff);
var x56: u32 = undefined;
var x57: u32 = undefined;
mulxU32(&x56, &x57, x40, 0xfffffffe);
var x58: u32 = undefined;
var x59: u32 = undefined;
mulxU32(&x58, &x59, x40, 0xffffffff);
var x60: u32 = undefined;
var x61: u32 = undefined;
mulxU32(&x60, &x61, x40, 0xffffffff);
var x62: u32 = undefined;
var x63: u1 = undefined;
addcarryxU32(&x62, &x63, 0x0, x59, x56);
var x64: u32 = undefined;
var x65: u1 = undefined;
addcarryxU32(&x64, &x65, x63, x57, x54);
var x66: u32 = undefined;
var x67: u1 = undefined;
addcarryxU32(&x66, &x67, x65, x55, x52);
var x68: u32 = undefined;
var x69: u1 = undefined;
addcarryxU32(&x68, &x69, x67, x53, x50);
var x70: u32 = undefined;
var x71: u1 = undefined;
addcarryxU32(&x70, &x71, x69, x51, x48);
var x72: u32 = undefined;
var x73: u1 = undefined;
addcarryxU32(&x72, &x73, x71, x49, x46);
var x74: u32 = undefined;
var x75: u1 = undefined;
addcarryxU32(&x74, &x75, x73, x47, x44);
var x76: u32 = undefined;
var x77: u1 = undefined;
addcarryxU32(&x76, &x77, x75, x45, x42);
var x78: u32 = undefined;
var x79: u1 = undefined;
addcarryxU32(&x78, &x79, 0x0, x40, x60);
var x80: u32 = undefined;
var x81: u1 = undefined;
addcarryxU32(&x80, &x81, x79, cast(u32, x41), x61);
var x82: u32 = undefined;
var x83: u1 = undefined;
addcarryxU32(&x82, &x83, x81, x18, cast(u32, 0x0));
var x84: u32 = undefined;
var x85: u1 = undefined;
addcarryxU32(&x84, &x85, x83, x22, x58);
var x86: u32 = undefined;
var x87: u1 = undefined;
addcarryxU32(&x86, &x87, x85, x24, x62);
var x88: u32 = undefined;
var x89: u1 = undefined;
addcarryxU32(&x88, &x89, x87, x26, x64);
var x90: u32 = undefined;
var x91: u1 = undefined;
addcarryxU32(&x90, &x91, x89, x28, x66);
var x92: u32 = undefined;
var x93: u1 = undefined;
addcarryxU32(&x92, &x93, x91, x30, x68);
var x94: u32 = undefined;
var x95: u1 = undefined;
addcarryxU32(&x94, &x95, x93, x32, x70);
var x96: u32 = undefined;
var x97: u1 = undefined;
addcarryxU32(&x96, &x97, x95, x34, x72);
var x98: u32 = undefined;
var x99: u1 = undefined;
addcarryxU32(&x98, &x99, x97, x36, x74);
var x100: u32 = undefined;
var x101: u1 = undefined;
addcarryxU32(&x100, &x101, x99, (cast(u32, x37) + x3), x76);
var x102: u32 = undefined;
var x103: u1 = undefined;
addcarryxU32(&x102, &x103, x101, cast(u32, 0x0), (cast(u32, x77) + x43));
var x104: u32 = undefined;
var x105: u1 = undefined;
addcarryxU32(&x104, &x105, 0x0, x80, (arg1[2]));
var x106: u32 = undefined;
var x107: u1 = undefined;
addcarryxU32(&x106, &x107, x105, x82, cast(u32, 0x0));
var x108: u32 = undefined;
var x109: u1 = undefined;
addcarryxU32(&x108, &x109, x107, x84, cast(u32, 0x0));
var x110: u32 = undefined;
var x111: u1 = undefined;
addcarryxU32(&x110, &x111, x109, x86, cast(u32, 0x0));
var x112: u32 = undefined;
var x113: u1 = undefined;
addcarryxU32(&x112, &x113, x111, x88, cast(u32, 0x0));
var x114: u32 = undefined;
var x115: u1 = undefined;
addcarryxU32(&x114, &x115, x113, x90, cast(u32, 0x0));
var x116: u32 = undefined;
var x117: u1 = undefined;
addcarryxU32(&x116, &x117, x115, x92, cast(u32, 0x0));
var x118: u32 = undefined;
var x119: u1 = undefined;
addcarryxU32(&x118, &x119, x117, x94, cast(u32, 0x0));
var x120: u32 = undefined;
var x121: u1 = undefined;
addcarryxU32(&x120, &x121, x119, x96, cast(u32, 0x0));
var x122: u32 = undefined;
var x123: u1 = undefined;
addcarryxU32(&x122, &x123, x121, x98, cast(u32, 0x0));
var x124: u32 = undefined;
var x125: u1 = undefined;
addcarryxU32(&x124, &x125, x123, x100, cast(u32, 0x0));
var x126: u32 = undefined;
var x127: u1 = undefined;
addcarryxU32(&x126, &x127, x125, x102, cast(u32, 0x0));
var x128: u32 = undefined;
var x129: u32 = undefined;
mulxU32(&x128, &x129, x104, 0xffffffff);
var x130: u32 = undefined;
var x131: u32 = undefined;
mulxU32(&x130, &x131, x104, 0xffffffff);
var x132: u32 = undefined;
var x133: u32 = undefined;
mulxU32(&x132, &x133, x104, 0xffffffff);
var x134: u32 = undefined;
var x135: u32 = undefined;
mulxU32(&x134, &x135, x104, 0xffffffff);
var x136: u32 = undefined;
var x137: u32 = undefined;
mulxU32(&x136, &x137, x104, 0xffffffff);
var x138: u32 = undefined;
var x139: u32 = undefined;
mulxU32(&x138, &x139, x104, 0xffffffff);
var x140: u32 = undefined;
var x141: u32 = undefined;
mulxU32(&x140, &x141, x104, 0xffffffff);
var x142: u32 = undefined;
var x143: u32 = undefined;
mulxU32(&x142, &x143, x104, 0xfffffffe);
var x144: u32 = undefined;
var x145: u32 = undefined;
mulxU32(&x144, &x145, x104, 0xffffffff);
var x146: u32 = undefined;
var x147: u32 = undefined;
mulxU32(&x146, &x147, x104, 0xffffffff);
var x148: u32 = undefined;
var x149: u1 = undefined;
addcarryxU32(&x148, &x149, 0x0, x145, x142);
var x150: u32 = undefined;
var x151: u1 = undefined;
addcarryxU32(&x150, &x151, x149, x143, x140);
var x152: u32 = undefined;
var x153: u1 = undefined;
addcarryxU32(&x152, &x153, x151, x141, x138);
var x154: u32 = undefined;
var x155: u1 = undefined;
addcarryxU32(&x154, &x155, x153, x139, x136);
var x156: u32 = undefined;
var x157: u1 = undefined;
addcarryxU32(&x156, &x157, x155, x137, x134);
var x158: u32 = undefined;
var x159: u1 = undefined;
addcarryxU32(&x158, &x159, x157, x135, x132);
var x160: u32 = undefined;
var x161: u1 = undefined;
addcarryxU32(&x160, &x161, x159, x133, x130);
var x162: u32 = undefined;
var x163: u1 = undefined;
addcarryxU32(&x162, &x163, x161, x131, x128);
var x164: u32 = undefined;
var x165: u1 = undefined;
addcarryxU32(&x164, &x165, 0x0, x104, x146);
var x166: u32 = undefined;
var x167: u1 = undefined;
addcarryxU32(&x166, &x167, x165, x106, x147);
var x168: u32 = undefined;
var x169: u1 = undefined;
addcarryxU32(&x168, &x169, x167, x108, cast(u32, 0x0));
var x170: u32 = undefined;
var x171: u1 = undefined;
addcarryxU32(&x170, &x171, x169, x110, x144);
var x172: u32 = undefined;
var x173: u1 = undefined;
addcarryxU32(&x172, &x173, x171, x112, x148);
var x174: u32 = undefined;
var x175: u1 = undefined;
addcarryxU32(&x174, &x175, x173, x114, x150);
var x176: u32 = undefined;
var x177: u1 = undefined;
addcarryxU32(&x176, &x177, x175, x116, x152);
var x178: u32 = undefined;
var x179: u1 = undefined;
addcarryxU32(&x178, &x179, x177, x118, x154);
var x180: u32 = undefined;
var x181: u1 = undefined;
addcarryxU32(&x180, &x181, x179, x120, x156);
var x182: u32 = undefined;
var x183: u1 = undefined;
addcarryxU32(&x182, &x183, x181, x122, x158);
var x184: u32 = undefined;
var x185: u1 = undefined;
addcarryxU32(&x184, &x185, x183, x124, x160);
var x186: u32 = undefined;
var x187: u1 = undefined;
addcarryxU32(&x186, &x187, x185, x126, x162);
var x188: u32 = undefined;
var x189: u1 = undefined;
addcarryxU32(&x188, &x189, x187, (cast(u32, x127) + cast(u32, x103)), (cast(u32, x163) + x129));
var x190: u32 = undefined;
var x191: u1 = undefined;
addcarryxU32(&x190, &x191, 0x0, x166, (arg1[3]));
var x192: u32 = undefined;
var x193: u1 = undefined;
addcarryxU32(&x192, &x193, x191, x168, cast(u32, 0x0));
var x194: u32 = undefined;
var x195: u1 = undefined;
addcarryxU32(&x194, &x195, x193, x170, cast(u32, 0x0));
var x196: u32 = undefined;
var x197: u1 = undefined;
addcarryxU32(&x196, &x197, x195, x172, cast(u32, 0x0));
var x198: u32 = undefined;
var x199: u1 = undefined;
addcarryxU32(&x198, &x199, x197, x174, cast(u32, 0x0));
var x200: u32 = undefined;
var x201: u1 = undefined;
addcarryxU32(&x200, &x201, x199, x176, cast(u32, 0x0));
var x202: u32 = undefined;
var x203: u1 = undefined;
addcarryxU32(&x202, &x203, x201, x178, cast(u32, 0x0));
var x204: u32 = undefined;
var x205: u1 = undefined;
addcarryxU32(&x204, &x205, x203, x180, cast(u32, 0x0));
var x206: u32 = undefined;
var x207: u1 = undefined;
addcarryxU32(&x206, &x207, x205, x182, cast(u32, 0x0));
var x208: u32 = undefined;
var x209: u1 = undefined;
addcarryxU32(&x208, &x209, x207, x184, cast(u32, 0x0));
var x210: u32 = undefined;
var x211: u1 = undefined;
addcarryxU32(&x210, &x211, x209, x186, cast(u32, 0x0));
var x212: u32 = undefined;
var x213: u1 = undefined;
addcarryxU32(&x212, &x213, x211, x188, cast(u32, 0x0));
var x214: u32 = undefined;
var x215: u32 = undefined;
mulxU32(&x214, &x215, x190, 0xffffffff);
var x216: u32 = undefined;
var x217: u32 = undefined;
mulxU32(&x216, &x217, x190, 0xffffffff);
var x218: u32 = undefined;
var x219: u32 = undefined;
mulxU32(&x218, &x219, x190, 0xffffffff);
var x220: u32 = undefined;
var x221: u32 = undefined;
mulxU32(&x220, &x221, x190, 0xffffffff);
var x222: u32 = undefined;
var x223: u32 = undefined;
mulxU32(&x222, &x223, x190, 0xffffffff);
var x224: u32 = undefined;
var x225: u32 = undefined;
mulxU32(&x224, &x225, x190, 0xffffffff);
var x226: u32 = undefined;
var x227: u32 = undefined;
mulxU32(&x226, &x227, x190, 0xffffffff);
var x228: u32 = undefined;
var x229: u32 = undefined;
mulxU32(&x228, &x229, x190, 0xfffffffe);
var x230: u32 = undefined;
var x231: u32 = undefined;
mulxU32(&x230, &x231, x190, 0xffffffff);
var x232: u32 = undefined;
var x233: u32 = undefined;
mulxU32(&x232, &x233, x190, 0xffffffff);
var x234: u32 = undefined;
var x235: u1 = undefined;
addcarryxU32(&x234, &x235, 0x0, x231, x228);
var x236: u32 = undefined;
var x237: u1 = undefined;
addcarryxU32(&x236, &x237, x235, x229, x226);
var x238: u32 = undefined;
var x239: u1 = undefined;
addcarryxU32(&x238, &x239, x237, x227, x224);
var x240: u32 = undefined;
var x241: u1 = undefined;
addcarryxU32(&x240, &x241, x239, x225, x222);
var x242: u32 = undefined;
var x243: u1 = undefined;
addcarryxU32(&x242, &x243, x241, x223, x220);
var x244: u32 = undefined;
var x245: u1 = undefined;
addcarryxU32(&x244, &x245, x243, x221, x218);
var x246: u32 = undefined;
var x247: u1 = undefined;
addcarryxU32(&x246, &x247, x245, x219, x216);
var x248: u32 = undefined;
var x249: u1 = undefined;
addcarryxU32(&x248, &x249, x247, x217, x214);
var x250: u32 = undefined;
var x251: u1 = undefined;
addcarryxU32(&x250, &x251, 0x0, x190, x232);
var x252: u32 = undefined;
var x253: u1 = undefined;
addcarryxU32(&x252, &x253, x251, x192, x233);
var x254: u32 = undefined;
var x255: u1 = undefined;
addcarryxU32(&x254, &x255, x253, x194, cast(u32, 0x0));
var x256: u32 = undefined;
var x257: u1 = undefined;
addcarryxU32(&x256, &x257, x255, x196, x230);
var x258: u32 = undefined;
var x259: u1 = undefined;
addcarryxU32(&x258, &x259, x257, x198, x234);
var x260: u32 = undefined;
var x261: u1 = undefined;
addcarryxU32(&x260, &x261, x259, x200, x236);
var x262: u32 = undefined;
var x263: u1 = undefined;
addcarryxU32(&x262, &x263, x261, x202, x238);
var x264: u32 = undefined;
var x265: u1 = undefined;
addcarryxU32(&x264, &x265, x263, x204, x240);
var x266: u32 = undefined;
var x267: u1 = undefined;
addcarryxU32(&x266, &x267, x265, x206, x242);
var x268: u32 = undefined;
var x269: u1 = undefined;
addcarryxU32(&x268, &x269, x267, x208, x244);
var x270: u32 = undefined;
var x271: u1 = undefined;
addcarryxU32(&x270, &x271, x269, x210, x246);
var x272: u32 = undefined;
var x273: u1 = undefined;
addcarryxU32(&x272, &x273, x271, x212, x248);
var x274: u32 = undefined;
var x275: u1 = undefined;
addcarryxU32(&x274, &x275, x273, (cast(u32, x213) + cast(u32, x189)), (cast(u32, x249) + x215));
var x276: u32 = undefined;
var x277: u1 = undefined;
addcarryxU32(&x276, &x277, 0x0, x252, (arg1[4]));
var x278: u32 = undefined;
var x279: u1 = undefined;
addcarryxU32(&x278, &x279, x277, x254, cast(u32, 0x0));
var x280: u32 = undefined;
var x281: u1 = undefined;
addcarryxU32(&x280, &x281, x279, x256, cast(u32, 0x0));
var x282: u32 = undefined;
var x283: u1 = undefined;
addcarryxU32(&x282, &x283, x281, x258, cast(u32, 0x0));
var x284: u32 = undefined;
var x285: u1 = undefined;
addcarryxU32(&x284, &x285, x283, x260, cast(u32, 0x0));
var x286: u32 = undefined;
var x287: u1 = undefined;
addcarryxU32(&x286, &x287, x285, x262, cast(u32, 0x0));
var x288: u32 = undefined;
var x289: u1 = undefined;
addcarryxU32(&x288, &x289, x287, x264, cast(u32, 0x0));
var x290: u32 = undefined;
var x291: u1 = undefined;
addcarryxU32(&x290, &x291, x289, x266, cast(u32, 0x0));
var x292: u32 = undefined;
var x293: u1 = undefined;
addcarryxU32(&x292, &x293, x291, x268, cast(u32, 0x0));
var x294: u32 = undefined;
var x295: u1 = undefined;
addcarryxU32(&x294, &x295, x293, x270, cast(u32, 0x0));
var x296: u32 = undefined;
var x297: u1 = undefined;
addcarryxU32(&x296, &x297, x295, x272, cast(u32, 0x0));
var x298: u32 = undefined;
var x299: u1 = undefined;
addcarryxU32(&x298, &x299, x297, x274, cast(u32, 0x0));
var x300: u32 = undefined;
var x301: u32 = undefined;
mulxU32(&x300, &x301, x276, 0xffffffff);
var x302: u32 = undefined;
var x303: u32 = undefined;
mulxU32(&x302, &x303, x276, 0xffffffff);
var x304: u32 = undefined;
var x305: u32 = undefined;
mulxU32(&x304, &x305, x276, 0xffffffff);
var x306: u32 = undefined;
var x307: u32 = undefined;
mulxU32(&x306, &x307, x276, 0xffffffff);
var x308: u32 = undefined;
var x309: u32 = undefined;
mulxU32(&x308, &x309, x276, 0xffffffff);
var x310: u32 = undefined;
var x311: u32 = undefined;
mulxU32(&x310, &x311, x276, 0xffffffff);
var x312: u32 = undefined;
var x313: u32 = undefined;
mulxU32(&x312, &x313, x276, 0xffffffff);
var x314: u32 = undefined;
var x315: u32 = undefined;
mulxU32(&x314, &x315, x276, 0xfffffffe);
var x316: u32 = undefined;
var x317: u32 = undefined;
mulxU32(&x316, &x317, x276, 0xffffffff);
var x318: u32 = undefined;
var x319: u32 = undefined;
mulxU32(&x318, &x319, x276, 0xffffffff);
var x320: u32 = undefined;
var x321: u1 = undefined;
addcarryxU32(&x320, &x321, 0x0, x317, x314);
var x322: u32 = undefined;
var x323: u1 = undefined;
addcarryxU32(&x322, &x323, x321, x315, x312);
var x324: u32 = undefined;
var x325: u1 = undefined;
addcarryxU32(&x324, &x325, x323, x313, x310);
var x326: u32 = undefined;
var x327: u1 = undefined;
addcarryxU32(&x326, &x327, x325, x311, x308);
var x328: u32 = undefined;
var x329: u1 = undefined;
addcarryxU32(&x328, &x329, x327, x309, x306);
var x330: u32 = undefined;
var x331: u1 = undefined;
addcarryxU32(&x330, &x331, x329, x307, x304);
var x332: u32 = undefined;
var x333: u1 = undefined;
addcarryxU32(&x332, &x333, x331, x305, x302);
var x334: u32 = undefined;
var x335: u1 = undefined;
addcarryxU32(&x334, &x335, x333, x303, x300);
var x336: u32 = undefined;
var x337: u1 = undefined;
addcarryxU32(&x336, &x337, 0x0, x276, x318);
var x338: u32 = undefined;
var x339: u1 = undefined;
addcarryxU32(&x338, &x339, x337, x278, x319);
var x340: u32 = undefined;
var x341: u1 = undefined;
addcarryxU32(&x340, &x341, x339, x280, cast(u32, 0x0));
var x342: u32 = undefined;
var x343: u1 = undefined;
addcarryxU32(&x342, &x343, x341, x282, x316);
var x344: u32 = undefined;
var x345: u1 = undefined;
addcarryxU32(&x344, &x345, x343, x284, x320);
var x346: u32 = undefined;
var x347: u1 = undefined;
addcarryxU32(&x346, &x347, x345, x286, x322);
var x348: u32 = undefined;
var x349: u1 = undefined;
addcarryxU32(&x348, &x349, x347, x288, x324);
var x350: u32 = undefined;
var x351: u1 = undefined;
addcarryxU32(&x350, &x351, x349, x290, x326);
var x352: u32 = undefined;
var x353: u1 = undefined;
addcarryxU32(&x352, &x353, x351, x292, x328);
var x354: u32 = undefined;
var x355: u1 = undefined;
addcarryxU32(&x354, &x355, x353, x294, x330);
var x356: u32 = undefined;
var x357: u1 = undefined;
addcarryxU32(&x356, &x357, x355, x296, x332);
var x358: u32 = undefined;
var x359: u1 = undefined;
addcarryxU32(&x358, &x359, x357, x298, x334);
var x360: u32 = undefined;
var x361: u1 = undefined;
addcarryxU32(&x360, &x361, x359, (cast(u32, x299) + cast(u32, x275)), (cast(u32, x335) + x301));
var x362: u32 = undefined;
var x363: u1 = undefined;
addcarryxU32(&x362, &x363, 0x0, x338, (arg1[5]));
var x364: u32 = undefined;
var x365: u1 = undefined;
addcarryxU32(&x364, &x365, x363, x340, cast(u32, 0x0));
var x366: u32 = undefined;
var x367: u1 = undefined;
addcarryxU32(&x366, &x367, x365, x342, cast(u32, 0x0));
var x368: u32 = undefined;
var x369: u1 = undefined;
addcarryxU32(&x368, &x369, x367, x344, cast(u32, 0x0));
var x370: u32 = undefined;
var x371: u1 = undefined;
addcarryxU32(&x370, &x371, x369, x346, cast(u32, 0x0));
var x372: u32 = undefined;
var x373: u1 = undefined;
addcarryxU32(&x372, &x373, x371, x348, cast(u32, 0x0));
var x374: u32 = undefined;
var x375: u1 = undefined;
addcarryxU32(&x374, &x375, x373, x350, cast(u32, 0x0));
var x376: u32 = undefined;
var x377: u1 = undefined;
addcarryxU32(&x376, &x377, x375, x352, cast(u32, 0x0));
var x378: u32 = undefined;
var x379: u1 = undefined;
addcarryxU32(&x378, &x379, x377, x354, cast(u32, 0x0));
var x380: u32 = undefined;
var x381: u1 = undefined;
addcarryxU32(&x380, &x381, x379, x356, cast(u32, 0x0));
var x382: u32 = undefined;
var x383: u1 = undefined;
addcarryxU32(&x382, &x383, x381, x358, cast(u32, 0x0));
var x384: u32 = undefined;
var x385: u1 = undefined;
addcarryxU32(&x384, &x385, x383, x360, cast(u32, 0x0));
var x386: u32 = undefined;
var x387: u32 = undefined;
mulxU32(&x386, &x387, x362, 0xffffffff);
var x388: u32 = undefined;
var x389: u32 = undefined;
mulxU32(&x388, &x389, x362, 0xffffffff);
var x390: u32 = undefined;
var x391: u32 = undefined;
mulxU32(&x390, &x391, x362, 0xffffffff);
var x392: u32 = undefined;
var x393: u32 = undefined;
mulxU32(&x392, &x393, x362, 0xffffffff);
var x394: u32 = undefined;
var x395: u32 = undefined;
mulxU32(&x394, &x395, x362, 0xffffffff);
var x396: u32 = undefined;
var x397: u32 = undefined;
mulxU32(&x396, &x397, x362, 0xffffffff);
var x398: u32 = undefined;
var x399: u32 = undefined;
mulxU32(&x398, &x399, x362, 0xffffffff);
var x400: u32 = undefined;
var x401: u32 = undefined;
mulxU32(&x400, &x401, x362, 0xfffffffe);
var x402: u32 = undefined;
var x403: u32 = undefined;
mulxU32(&x402, &x403, x362, 0xffffffff);
var x404: u32 = undefined;
var x405: u32 = undefined;
mulxU32(&x404, &x405, x362, 0xffffffff);
var x406: u32 = undefined;
var x407: u1 = undefined;
addcarryxU32(&x406, &x407, 0x0, x403, x400);
var x408: u32 = undefined;
var x409: u1 = undefined;
addcarryxU32(&x408, &x409, x407, x401, x398);
var x410: u32 = undefined;
var x411: u1 = undefined;
addcarryxU32(&x410, &x411, x409, x399, x396);
var x412: u32 = undefined;
var x413: u1 = undefined;
addcarryxU32(&x412, &x413, x411, x397, x394);
var x414: u32 = undefined;
var x415: u1 = undefined;
addcarryxU32(&x414, &x415, x413, x395, x392);
var x416: u32 = undefined;
var x417: u1 = undefined;
addcarryxU32(&x416, &x417, x415, x393, x390);
var x418: u32 = undefined;
var x419: u1 = undefined;
addcarryxU32(&x418, &x419, x417, x391, x388);
var x420: u32 = undefined;
var x421: u1 = undefined;
addcarryxU32(&x420, &x421, x419, x389, x386);
var x422: u32 = undefined;
var x423: u1 = undefined;
addcarryxU32(&x422, &x423, 0x0, x362, x404);
var x424: u32 = undefined;
var x425: u1 = undefined;
addcarryxU32(&x424, &x425, x423, x364, x405);
var x426: u32 = undefined;
var x427: u1 = undefined;
addcarryxU32(&x426, &x427, x425, x366, cast(u32, 0x0));
var x428: u32 = undefined;
var x429: u1 = undefined;
addcarryxU32(&x428, &x429, x427, x368, x402);
var x430: u32 = undefined;
var x431: u1 = undefined;
addcarryxU32(&x430, &x431, x429, x370, x406);
var x432: u32 = undefined;
var x433: u1 = undefined;
addcarryxU32(&x432, &x433, x431, x372, x408);
var x434: u32 = undefined;
var x435: u1 = undefined;
addcarryxU32(&x434, &x435, x433, x374, x410);
var x436: u32 = undefined;
var x437: u1 = undefined;
addcarryxU32(&x436, &x437, x435, x376, x412);
var x438: u32 = undefined;
var x439: u1 = undefined;
addcarryxU32(&x438, &x439, x437, x378, x414);
var x440: u32 = undefined;
var x441: u1 = undefined;
addcarryxU32(&x440, &x441, x439, x380, x416);
var x442: u32 = undefined;
var x443: u1 = undefined;
addcarryxU32(&x442, &x443, x441, x382, x418);
var x444: u32 = undefined;
var x445: u1 = undefined;
addcarryxU32(&x444, &x445, x443, x384, x420);
var x446: u32 = undefined;
var x447: u1 = undefined;
addcarryxU32(&x446, &x447, x445, (cast(u32, x385) + cast(u32, x361)), (cast(u32, x421) + x387));
var x448: u32 = undefined;
var x449: u1 = undefined;
addcarryxU32(&x448, &x449, 0x0, x424, (arg1[6]));
var x450: u32 = undefined;
var x451: u1 = undefined;
addcarryxU32(&x450, &x451, x449, x426, cast(u32, 0x0));
var x452: u32 = undefined;
var x453: u1 = undefined;
addcarryxU32(&x452, &x453, x451, x428, cast(u32, 0x0));
var x454: u32 = undefined;
var x455: u1 = undefined;
addcarryxU32(&x454, &x455, x453, x430, cast(u32, 0x0));
var x456: u32 = undefined;
var x457: u1 = undefined;
addcarryxU32(&x456, &x457, x455, x432, cast(u32, 0x0));
var x458: u32 = undefined;
var x459: u1 = undefined;
addcarryxU32(&x458, &x459, x457, x434, cast(u32, 0x0));
var x460: u32 = undefined;
var x461: u1 = undefined;
addcarryxU32(&x460, &x461, x459, x436, cast(u32, 0x0));
var x462: u32 = undefined;
var x463: u1 = undefined;
addcarryxU32(&x462, &x463, x461, x438, cast(u32, 0x0));
var x464: u32 = undefined;
var x465: u1 = undefined;
addcarryxU32(&x464, &x465, x463, x440, cast(u32, 0x0));
var x466: u32 = undefined;
var x467: u1 = undefined;
addcarryxU32(&x466, &x467, x465, x442, cast(u32, 0x0));
var x468: u32 = undefined;
var x469: u1 = undefined;
addcarryxU32(&x468, &x469, x467, x444, cast(u32, 0x0));
var x470: u32 = undefined;
var x471: u1 = undefined;
addcarryxU32(&x470, &x471, x469, x446, cast(u32, 0x0));
var x472: u32 = undefined;
var x473: u32 = undefined;
mulxU32(&x472, &x473, x448, 0xffffffff);
var x474: u32 = undefined;
var x475: u32 = undefined;
mulxU32(&x474, &x475, x448, 0xffffffff);
var x476: u32 = undefined;
var x477: u32 = undefined;
mulxU32(&x476, &x477, x448, 0xffffffff);
var x478: u32 = undefined;
var x479: u32 = undefined;
mulxU32(&x478, &x479, x448, 0xffffffff);
var x480: u32 = undefined;
var x481: u32 = undefined;
mulxU32(&x480, &x481, x448, 0xffffffff);
var x482: u32 = undefined;
var x483: u32 = undefined;
mulxU32(&x482, &x483, x448, 0xffffffff);
var x484: u32 = undefined;
var x485: u32 = undefined;
mulxU32(&x484, &x485, x448, 0xffffffff);
var x486: u32 = undefined;
var x487: u32 = undefined;
mulxU32(&x486, &x487, x448, 0xfffffffe);
var x488: u32 = undefined;
var x489: u32 = undefined;
mulxU32(&x488, &x489, x448, 0xffffffff);
var x490: u32 = undefined;
var x491: u32 = undefined;
mulxU32(&x490, &x491, x448, 0xffffffff);
var x492: u32 = undefined;
var x493: u1 = undefined;
addcarryxU32(&x492, &x493, 0x0, x489, x486);
var x494: u32 = undefined;
var x495: u1 = undefined;
addcarryxU32(&x494, &x495, x493, x487, x484);
var x496: u32 = undefined;
var x497: u1 = undefined;
addcarryxU32(&x496, &x497, x495, x485, x482);
var x498: u32 = undefined;
var x499: u1 = undefined;
addcarryxU32(&x498, &x499, x497, x483, x480);
var x500: u32 = undefined;
var x501: u1 = undefined;
addcarryxU32(&x500, &x501, x499, x481, x478);
var x502: u32 = undefined;
var x503: u1 = undefined;
addcarryxU32(&x502, &x503, x501, x479, x476);
var x504: u32 = undefined;
var x505: u1 = undefined;
addcarryxU32(&x504, &x505, x503, x477, x474);
var x506: u32 = undefined;
var x507: u1 = undefined;
addcarryxU32(&x506, &x507, x505, x475, x472);
var x508: u32 = undefined;
var x509: u1 = undefined;
addcarryxU32(&x508, &x509, 0x0, x448, x490);
var x510: u32 = undefined;
var x511: u1 = undefined;
addcarryxU32(&x510, &x511, x509, x450, x491);
var x512: u32 = undefined;
var x513: u1 = undefined;
addcarryxU32(&x512, &x513, x511, x452, cast(u32, 0x0));
var x514: u32 = undefined;
var x515: u1 = undefined;
addcarryxU32(&x514, &x515, x513, x454, x488);
var x516: u32 = undefined;
var x517: u1 = undefined;
addcarryxU32(&x516, &x517, x515, x456, x492);
var x518: u32 = undefined;
var x519: u1 = undefined;
addcarryxU32(&x518, &x519, x517, x458, x494);
var x520: u32 = undefined;
var x521: u1 = undefined;
addcarryxU32(&x520, &x521, x519, x460, x496);
var x522: u32 = undefined;
var x523: u1 = undefined;
addcarryxU32(&x522, &x523, x521, x462, x498);
var x524: u32 = undefined;
var x525: u1 = undefined;
addcarryxU32(&x524, &x525, x523, x464, x500);
var x526: u32 = undefined;
var x527: u1 = undefined;
addcarryxU32(&x526, &x527, x525, x466, x502);
var x528: u32 = undefined;
var x529: u1 = undefined;
addcarryxU32(&x528, &x529, x527, x468, x504);
var x530: u32 = undefined;
var x531: u1 = undefined;
addcarryxU32(&x530, &x531, x529, x470, x506);
var x532: u32 = undefined;
var x533: u1 = undefined;
addcarryxU32(&x532, &x533, x531, (cast(u32, x471) + cast(u32, x447)), (cast(u32, x507) + x473));
var x534: u32 = undefined;
var x535: u1 = undefined;
addcarryxU32(&x534, &x535, 0x0, x510, (arg1[7]));
var x536: u32 = undefined;
var x537: u1 = undefined;
addcarryxU32(&x536, &x537, x535, x512, cast(u32, 0x0));
var x538: u32 = undefined;
var x539: u1 = undefined;
addcarryxU32(&x538, &x539, x537, x514, cast(u32, 0x0));
var x540: u32 = undefined;
var x541: u1 = undefined;
addcarryxU32(&x540, &x541, x539, x516, cast(u32, 0x0));
var x542: u32 = undefined;
var x543: u1 = undefined;
addcarryxU32(&x542, &x543, x541, x518, cast(u32, 0x0));
var x544: u32 = undefined;
var x545: u1 = undefined;
addcarryxU32(&x544, &x545, x543, x520, cast(u32, 0x0));
var x546: u32 = undefined;
var x547: u1 = undefined;
addcarryxU32(&x546, &x547, x545, x522, cast(u32, 0x0));
var x548: u32 = undefined;
var x549: u1 = undefined;
addcarryxU32(&x548, &x549, x547, x524, cast(u32, 0x0));
var x550: u32 = undefined;
var x551: u1 = undefined;
addcarryxU32(&x550, &x551, x549, x526, cast(u32, 0x0));
var x552: u32 = undefined;
var x553: u1 = undefined;
addcarryxU32(&x552, &x553, x551, x528, cast(u32, 0x0));
var x554: u32 = undefined;
var x555: u1 = undefined;
addcarryxU32(&x554, &x555, x553, x530, cast(u32, 0x0));
var x556: u32 = undefined;
var x557: u1 = undefined;
addcarryxU32(&x556, &x557, x555, x532, cast(u32, 0x0));
var x558: u32 = undefined;
var x559: u32 = undefined;
mulxU32(&x558, &x559, x534, 0xffffffff);
var x560: u32 = undefined;
var x561: u32 = undefined;
mulxU32(&x560, &x561, x534, 0xffffffff);
var x562: u32 = undefined;
var x563: u32 = undefined;
mulxU32(&x562, &x563, x534, 0xffffffff);
var x564: u32 = undefined;
var x565: u32 = undefined;
mulxU32(&x564, &x565, x534, 0xffffffff);
var x566: u32 = undefined;
var x567: u32 = undefined;
mulxU32(&x566, &x567, x534, 0xffffffff);
var x568: u32 = undefined;
var x569: u32 = undefined;
mulxU32(&x568, &x569, x534, 0xffffffff);
var x570: u32 = undefined;
var x571: u32 = undefined;
mulxU32(&x570, &x571, x534, 0xffffffff);
var x572: u32 = undefined;
var x573: u32 = undefined;
mulxU32(&x572, &x573, x534, 0xfffffffe);
var x574: u32 = undefined;
var x575: u32 = undefined;
mulxU32(&x574, &x575, x534, 0xffffffff);
var x576: u32 = undefined;
var x577: u32 = undefined;
mulxU32(&x576, &x577, x534, 0xffffffff);
var x578: u32 = undefined;
var x579: u1 = undefined;
addcarryxU32(&x578, &x579, 0x0, x575, x572);
var x580: u32 = undefined;
var x581: u1 = undefined;
addcarryxU32(&x580, &x581, x579, x573, x570);
var x582: u32 = undefined;
var x583: u1 = undefined;
addcarryxU32(&x582, &x583, x581, x571, x568);
var x584: u32 = undefined;
var x585: u1 = undefined;
addcarryxU32(&x584, &x585, x583, x569, x566);
var x586: u32 = undefined;
var x587: u1 = undefined;
addcarryxU32(&x586, &x587, x585, x567, x564);
var x588: u32 = undefined;
var x589: u1 = undefined;
addcarryxU32(&x588, &x589, x587, x565, x562);
var x590: u32 = undefined;
var x591: u1 = undefined;
addcarryxU32(&x590, &x591, x589, x563, x560);
var x592: u32 = undefined;
var x593: u1 = undefined;
addcarryxU32(&x592, &x593, x591, x561, x558);
var x594: u32 = undefined;
var x595: u1 = undefined;
addcarryxU32(&x594, &x595, 0x0, x534, x576);
var x596: u32 = undefined;
var x597: u1 = undefined;
addcarryxU32(&x596, &x597, x595, x536, x577);
var x598: u32 = undefined;
var x599: u1 = undefined;
addcarryxU32(&x598, &x599, x597, x538, cast(u32, 0x0));
var x600: u32 = undefined;
var x601: u1 = undefined;
addcarryxU32(&x600, &x601, x599, x540, x574);
var x602: u32 = undefined;
var x603: u1 = undefined;
addcarryxU32(&x602, &x603, x601, x542, x578);
var x604: u32 = undefined;
var x605: u1 = undefined;
addcarryxU32(&x604, &x605, x603, x544, x580);
var x606: u32 = undefined;
var x607: u1 = undefined;
addcarryxU32(&x606, &x607, x605, x546, x582);
var x608: u32 = undefined;
var x609: u1 = undefined;
addcarryxU32(&x608, &x609, x607, x548, x584);
var x610: u32 = undefined;
var x611: u1 = undefined;
addcarryxU32(&x610, &x611, x609, x550, x586);
var x612: u32 = undefined;
var x613: u1 = undefined;
addcarryxU32(&x612, &x613, x611, x552, x588);
var x614: u32 = undefined;
var x615: u1 = undefined;
addcarryxU32(&x614, &x615, x613, x554, x590);
var x616: u32 = undefined;
var x617: u1 = undefined;
addcarryxU32(&x616, &x617, x615, x556, x592);
var x618: u32 = undefined;
var x619: u1 = undefined;
addcarryxU32(&x618, &x619, x617, (cast(u32, x557) + cast(u32, x533)), (cast(u32, x593) + x559));
var x620: u32 = undefined;
var x621: u1 = undefined;
addcarryxU32(&x620, &x621, 0x0, x596, (arg1[8]));
var x622: u32 = undefined;
var x623: u1 = undefined;
addcarryxU32(&x622, &x623, x621, x598, cast(u32, 0x0));
var x624: u32 = undefined;
var x625: u1 = undefined;
addcarryxU32(&x624, &x625, x623, x600, cast(u32, 0x0));
var x626: u32 = undefined;
var x627: u1 = undefined;
addcarryxU32(&x626, &x627, x625, x602, cast(u32, 0x0));
var x628: u32 = undefined;
var x629: u1 = undefined;
addcarryxU32(&x628, &x629, x627, x604, cast(u32, 0x0));
var x630: u32 = undefined;
var x631: u1 = undefined;
addcarryxU32(&x630, &x631, x629, x606, cast(u32, 0x0));
var x632: u32 = undefined;
var x633: u1 = undefined;
addcarryxU32(&x632, &x633, x631, x608, cast(u32, 0x0));
var x634: u32 = undefined;
var x635: u1 = undefined;
addcarryxU32(&x634, &x635, x633, x610, cast(u32, 0x0));
var x636: u32 = undefined;
var x637: u1 = undefined;
addcarryxU32(&x636, &x637, x635, x612, cast(u32, 0x0));
var x638: u32 = undefined;
var x639: u1 = undefined;
addcarryxU32(&x638, &x639, x637, x614, cast(u32, 0x0));
var x640: u32 = undefined;
var x641: u1 = undefined;
addcarryxU32(&x640, &x641, x639, x616, cast(u32, 0x0));
var x642: u32 = undefined;
var x643: u1 = undefined;
addcarryxU32(&x642, &x643, x641, x618, cast(u32, 0x0));
var x644: u32 = undefined;
var x645: u32 = undefined;
mulxU32(&x644, &x645, x620, 0xffffffff);
var x646: u32 = undefined;
var x647: u32 = undefined;
mulxU32(&x646, &x647, x620, 0xffffffff);
var x648: u32 = undefined;
var x649: u32 = undefined;
mulxU32(&x648, &x649, x620, 0xffffffff);
var x650: u32 = undefined;
var x651: u32 = undefined;
mulxU32(&x650, &x651, x620, 0xffffffff);
var x652: u32 = undefined;
var x653: u32 = undefined;
mulxU32(&x652, &x653, x620, 0xffffffff);
var x654: u32 = undefined;
var x655: u32 = undefined;
mulxU32(&x654, &x655, x620, 0xffffffff);
var x656: u32 = undefined;
var x657: u32 = undefined;
mulxU32(&x656, &x657, x620, 0xffffffff);
var x658: u32 = undefined;
var x659: u32 = undefined;
mulxU32(&x658, &x659, x620, 0xfffffffe);
var x660: u32 = undefined;
var x661: u32 = undefined;
mulxU32(&x660, &x661, x620, 0xffffffff);
var x662: u32 = undefined;
var x663: u32 = undefined;
mulxU32(&x662, &x663, x620, 0xffffffff);
var x664: u32 = undefined;
var x665: u1 = undefined;
addcarryxU32(&x664, &x665, 0x0, x661, x658);
var x666: u32 = undefined;
var x667: u1 = undefined;
addcarryxU32(&x666, &x667, x665, x659, x656);
var x668: u32 = undefined;
var x669: u1 = undefined;
addcarryxU32(&x668, &x669, x667, x657, x654);
var x670: u32 = undefined;
var x671: u1 = undefined;
addcarryxU32(&x670, &x671, x669, x655, x652);
var x672: u32 = undefined;
var x673: u1 = undefined;
addcarryxU32(&x672, &x673, x671, x653, x650);
var x674: u32 = undefined;
var x675: u1 = undefined;
addcarryxU32(&x674, &x675, x673, x651, x648);
var x676: u32 = undefined;
var x677: u1 = undefined;
addcarryxU32(&x676, &x677, x675, x649, x646);
var x678: u32 = undefined;
var x679: u1 = undefined;
addcarryxU32(&x678, &x679, x677, x647, x644);
var x680: u32 = undefined;
var x681: u1 = undefined;
addcarryxU32(&x680, &x681, 0x0, x620, x662);
var x682: u32 = undefined;
var x683: u1 = undefined;
addcarryxU32(&x682, &x683, x681, x622, x663);
var x684: u32 = undefined;
var x685: u1 = undefined;
addcarryxU32(&x684, &x685, x683, x624, cast(u32, 0x0));
var x686: u32 = undefined;
var x687: u1 = undefined;
addcarryxU32(&x686, &x687, x685, x626, x660);
var x688: u32 = undefined;
var x689: u1 = undefined;
addcarryxU32(&x688, &x689, x687, x628, x664);
var x690: u32 = undefined;
var x691: u1 = undefined;
addcarryxU32(&x690, &x691, x689, x630, x666);
var x692: u32 = undefined;
var x693: u1 = undefined;
addcarryxU32(&x692, &x693, x691, x632, x668);
var x694: u32 = undefined;
var x695: u1 = undefined;
addcarryxU32(&x694, &x695, x693, x634, x670);
var x696: u32 = undefined;
var x697: u1 = undefined;
addcarryxU32(&x696, &x697, x695, x636, x672);
var x698: u32 = undefined;
var x699: u1 = undefined;
addcarryxU32(&x698, &x699, x697, x638, x674);
var x700: u32 = undefined;
var x701: u1 = undefined;
addcarryxU32(&x700, &x701, x699, x640, x676);
var x702: u32 = undefined;
var x703: u1 = undefined;
addcarryxU32(&x702, &x703, x701, x642, x678);
var x704: u32 = undefined;
var x705: u1 = undefined;
addcarryxU32(&x704, &x705, x703, (cast(u32, x643) + cast(u32, x619)), (cast(u32, x679) + x645));
var x706: u32 = undefined;
var x707: u1 = undefined;
addcarryxU32(&x706, &x707, 0x0, x682, (arg1[9]));
var x708: u32 = undefined;
var x709: u1 = undefined;
addcarryxU32(&x708, &x709, x707, x684, cast(u32, 0x0));
var x710: u32 = undefined;
var x711: u1 = undefined;
addcarryxU32(&x710, &x711, x709, x686, cast(u32, 0x0));
var x712: u32 = undefined;
var x713: u1 = undefined;
addcarryxU32(&x712, &x713, x711, x688, cast(u32, 0x0));
var x714: u32 = undefined;
var x715: u1 = undefined;
addcarryxU32(&x714, &x715, x713, x690, cast(u32, 0x0));
var x716: u32 = undefined;
var x717: u1 = undefined;
addcarryxU32(&x716, &x717, x715, x692, cast(u32, 0x0));
var x718: u32 = undefined;
var x719: u1 = undefined;
addcarryxU32(&x718, &x719, x717, x694, cast(u32, 0x0));
var x720: u32 = undefined;
var x721: u1 = undefined;
addcarryxU32(&x720, &x721, x719, x696, cast(u32, 0x0));
var x722: u32 = undefined;
var x723: u1 = undefined;
addcarryxU32(&x722, &x723, x721, x698, cast(u32, 0x0));
var x724: u32 = undefined;
var x725: u1 = undefined;
addcarryxU32(&x724, &x725, x723, x700, cast(u32, 0x0));
var x726: u32 = undefined;
var x727: u1 = undefined;
addcarryxU32(&x726, &x727, x725, x702, cast(u32, 0x0));
var x728: u32 = undefined;
var x729: u1 = undefined;
addcarryxU32(&x728, &x729, x727, x704, cast(u32, 0x0));
var x730: u32 = undefined;
var x731: u32 = undefined;
mulxU32(&x730, &x731, x706, 0xffffffff);
var x732: u32 = undefined;
var x733: u32 = undefined;
mulxU32(&x732, &x733, x706, 0xffffffff);
var x734: u32 = undefined;
var x735: u32 = undefined;
mulxU32(&x734, &x735, x706, 0xffffffff);
var x736: u32 = undefined;
var x737: u32 = undefined;
mulxU32(&x736, &x737, x706, 0xffffffff);
var x738: u32 = undefined;
var x739: u32 = undefined;
mulxU32(&x738, &x739, x706, 0xffffffff);
var x740: u32 = undefined;
var x741: u32 = undefined;
mulxU32(&x740, &x741, x706, 0xffffffff);
var x742: u32 = undefined;
var x743: u32 = undefined;
mulxU32(&x742, &x743, x706, 0xffffffff);
var x744: u32 = undefined;
var x745: u32 = undefined;
mulxU32(&x744, &x745, x706, 0xfffffffe);
var x746: u32 = undefined;
var x747: u32 = undefined;
mulxU32(&x746, &x747, x706, 0xffffffff);
var x748: u32 = undefined;
var x749: u32 = undefined;
mulxU32(&x748, &x749, x706, 0xffffffff);
var x750: u32 = undefined;
var x751: u1 = undefined;
addcarryxU32(&x750, &x751, 0x0, x747, x744);
var x752: u32 = undefined;
var x753: u1 = undefined;
addcarryxU32(&x752, &x753, x751, x745, x742);
var x754: u32 = undefined;
var x755: u1 = undefined;
addcarryxU32(&x754, &x755, x753, x743, x740);
var x756: u32 = undefined;
var x757: u1 = undefined;
addcarryxU32(&x756, &x757, x755, x741, x738);
var x758: u32 = undefined;
var x759: u1 = undefined;
addcarryxU32(&x758, &x759, x757, x739, x736);
var x760: u32 = undefined;
var x761: u1 = undefined;
addcarryxU32(&x760, &x761, x759, x737, x734);
var x762: u32 = undefined;
var x763: u1 = undefined;
addcarryxU32(&x762, &x763, x761, x735, x732);
var x764: u32 = undefined;
var x765: u1 = undefined;
addcarryxU32(&x764, &x765, x763, x733, x730);
var x766: u32 = undefined;
var x767: u1 = undefined;
addcarryxU32(&x766, &x767, 0x0, x706, x748);
var x768: u32 = undefined;
var x769: u1 = undefined;
addcarryxU32(&x768, &x769, x767, x708, x749);
var x770: u32 = undefined;
var x771: u1 = undefined;
addcarryxU32(&x770, &x771, x769, x710, cast(u32, 0x0));
var x772: u32 = undefined;
var x773: u1 = undefined;
addcarryxU32(&x772, &x773, x771, x712, x746);
var x774: u32 = undefined;
var x775: u1 = undefined;
addcarryxU32(&x774, &x775, x773, x714, x750);
var x776: u32 = undefined;
var x777: u1 = undefined;
addcarryxU32(&x776, &x777, x775, x716, x752);
var x778: u32 = undefined;
var x779: u1 = undefined;
addcarryxU32(&x778, &x779, x777, x718, x754);
var x780: u32 = undefined;
var x781: u1 = undefined;
addcarryxU32(&x780, &x781, x779, x720, x756);
var x782: u32 = undefined;
var x783: u1 = undefined;
addcarryxU32(&x782, &x783, x781, x722, x758);
var x784: u32 = undefined;
var x785: u1 = undefined;
addcarryxU32(&x784, &x785, x783, x724, x760);
var x786: u32 = undefined;
var x787: u1 = undefined;
addcarryxU32(&x786, &x787, x785, x726, x762);
var x788: u32 = undefined;
var x789: u1 = undefined;
addcarryxU32(&x788, &x789, x787, x728, x764);
var x790: u32 = undefined;
var x791: u1 = undefined;
addcarryxU32(&x790, &x791, x789, (cast(u32, x729) + cast(u32, x705)), (cast(u32, x765) + x731));
var x792: u32 = undefined;
var x793: u1 = undefined;
addcarryxU32(&x792, &x793, 0x0, x768, (arg1[10]));
var x794: u32 = undefined;
var x795: u1 = undefined;
addcarryxU32(&x794, &x795, x793, x770, cast(u32, 0x0));
var x796: u32 = undefined;
var x797: u1 = undefined;
addcarryxU32(&x796, &x797, x795, x772, cast(u32, 0x0));
var x798: u32 = undefined;
var x799: u1 = undefined;
addcarryxU32(&x798, &x799, x797, x774, cast(u32, 0x0));
var x800: u32 = undefined;
var x801: u1 = undefined;
addcarryxU32(&x800, &x801, x799, x776, cast(u32, 0x0));
var x802: u32 = undefined;
var x803: u1 = undefined;
addcarryxU32(&x802, &x803, x801, x778, cast(u32, 0x0));
var x804: u32 = undefined;
var x805: u1 = undefined;
addcarryxU32(&x804, &x805, x803, x780, cast(u32, 0x0));
var x806: u32 = undefined;
var x807: u1 = undefined;
addcarryxU32(&x806, &x807, x805, x782, cast(u32, 0x0));
var x808: u32 = undefined;
var x809: u1 = undefined;
addcarryxU32(&x808, &x809, x807, x784, cast(u32, 0x0));
var x810: u32 = undefined;
var x811: u1 = undefined;
addcarryxU32(&x810, &x811, x809, x786, cast(u32, 0x0));
var x812: u32 = undefined;
var x813: u1 = undefined;
addcarryxU32(&x812, &x813, x811, x788, cast(u32, 0x0));
var x814: u32 = undefined;
var x815: u1 = undefined;
addcarryxU32(&x814, &x815, x813, x790, cast(u32, 0x0));
var x816: u32 = undefined;
var x817: u32 = undefined;
mulxU32(&x816, &x817, x792, 0xffffffff);
var x818: u32 = undefined;
var x819: u32 = undefined;
mulxU32(&x818, &x819, x792, 0xffffffff);
var x820: u32 = undefined;
var x821: u32 = undefined;
mulxU32(&x820, &x821, x792, 0xffffffff);
var x822: u32 = undefined;
var x823: u32 = undefined;
mulxU32(&x822, &x823, x792, 0xffffffff);
var x824: u32 = undefined;
var x825: u32 = undefined;
mulxU32(&x824, &x825, x792, 0xffffffff);
var x826: u32 = undefined;
var x827: u32 = undefined;
mulxU32(&x826, &x827, x792, 0xffffffff);
var x828: u32 = undefined;
var x829: u32 = undefined;
mulxU32(&x828, &x829, x792, 0xffffffff);
var x830: u32 = undefined;
var x831: u32 = undefined;
mulxU32(&x830, &x831, x792, 0xfffffffe);
var x832: u32 = undefined;
var x833: u32 = undefined;
mulxU32(&x832, &x833, x792, 0xffffffff);
var x834: u32 = undefined;
var x835: u32 = undefined;
mulxU32(&x834, &x835, x792, 0xffffffff);
var x836: u32 = undefined;
var x837: u1 = undefined;
addcarryxU32(&x836, &x837, 0x0, x833, x830);
var x838: u32 = undefined;
var x839: u1 = undefined;
addcarryxU32(&x838, &x839, x837, x831, x828);
var x840: u32 = undefined;
var x841: u1 = undefined;
addcarryxU32(&x840, &x841, x839, x829, x826);
var x842: u32 = undefined;
var x843: u1 = undefined;
addcarryxU32(&x842, &x843, x841, x827, x824);
var x844: u32 = undefined;
var x845: u1 = undefined;
addcarryxU32(&x844, &x845, x843, x825, x822);
var x846: u32 = undefined;
var x847: u1 = undefined;
addcarryxU32(&x846, &x847, x845, x823, x820);
var x848: u32 = undefined;
var x849: u1 = undefined;
addcarryxU32(&x848, &x849, x847, x821, x818);
var x850: u32 = undefined;
var x851: u1 = undefined;
addcarryxU32(&x850, &x851, x849, x819, x816);
var x852: u32 = undefined;
var x853: u1 = undefined;
addcarryxU32(&x852, &x853, 0x0, x792, x834);
var x854: u32 = undefined;
var x855: u1 = undefined;
addcarryxU32(&x854, &x855, x853, x794, x835);
var x856: u32 = undefined;
var x857: u1 = undefined;
addcarryxU32(&x856, &x857, x855, x796, cast(u32, 0x0));
var x858: u32 = undefined;
var x859: u1 = undefined;
addcarryxU32(&x858, &x859, x857, x798, x832);
var x860: u32 = undefined;
var x861: u1 = undefined;
addcarryxU32(&x860, &x861, x859, x800, x836);
var x862: u32 = undefined;
var x863: u1 = undefined;
addcarryxU32(&x862, &x863, x861, x802, x838);
var x864: u32 = undefined;
var x865: u1 = undefined;
addcarryxU32(&x864, &x865, x863, x804, x840);
var x866: u32 = undefined;
var x867: u1 = undefined;
addcarryxU32(&x866, &x867, x865, x806, x842);
var x868: u32 = undefined;
var x869: u1 = undefined;
addcarryxU32(&x868, &x869, x867, x808, x844);
var x870: u32 = undefined;
var x871: u1 = undefined;
addcarryxU32(&x870, &x871, x869, x810, x846);
var x872: u32 = undefined;
var x873: u1 = undefined;
addcarryxU32(&x872, &x873, x871, x812, x848);
var x874: u32 = undefined;
var x875: u1 = undefined;
addcarryxU32(&x874, &x875, x873, x814, x850);
var x876: u32 = undefined;
var x877: u1 = undefined;
addcarryxU32(&x876, &x877, x875, (cast(u32, x815) + cast(u32, x791)), (cast(u32, x851) + x817));
var x878: u32 = undefined;
var x879: u1 = undefined;
addcarryxU32(&x878, &x879, 0x0, x854, (arg1[11]));
var x880: u32 = undefined;
var x881: u1 = undefined;
addcarryxU32(&x880, &x881, x879, x856, cast(u32, 0x0));
var x882: u32 = undefined;
var x883: u1 = undefined;
addcarryxU32(&x882, &x883, x881, x858, cast(u32, 0x0));
var x884: u32 = undefined;
var x885: u1 = undefined;
addcarryxU32(&x884, &x885, x883, x860, cast(u32, 0x0));
var x886: u32 = undefined;
var x887: u1 = undefined;
addcarryxU32(&x886, &x887, x885, x862, cast(u32, 0x0));
var x888: u32 = undefined;
var x889: u1 = undefined;
addcarryxU32(&x888, &x889, x887, x864, cast(u32, 0x0));
var x890: u32 = undefined;
var x891: u1 = undefined;
addcarryxU32(&x890, &x891, x889, x866, cast(u32, 0x0));
var x892: u32 = undefined;
var x893: u1 = undefined;
addcarryxU32(&x892, &x893, x891, x868, cast(u32, 0x0));
var x894: u32 = undefined;
var x895: u1 = undefined;
addcarryxU32(&x894, &x895, x893, x870, cast(u32, 0x0));
var x896: u32 = undefined;
var x897: u1 = undefined;
addcarryxU32(&x896, &x897, x895, x872, cast(u32, 0x0));
var x898: u32 = undefined;
var x899: u1 = undefined;
addcarryxU32(&x898, &x899, x897, x874, cast(u32, 0x0));
var x900: u32 = undefined;
var x901: u1 = undefined;
addcarryxU32(&x900, &x901, x899, x876, cast(u32, 0x0));
var x902: u32 = undefined;
var x903: u32 = undefined;
mulxU32(&x902, &x903, x878, 0xffffffff);
var x904: u32 = undefined;
var x905: u32 = undefined;
mulxU32(&x904, &x905, x878, 0xffffffff);
var x906: u32 = undefined;
var x907: u32 = undefined;
mulxU32(&x906, &x907, x878, 0xffffffff);
var x908: u32 = undefined;
var x909: u32 = undefined;
mulxU32(&x908, &x909, x878, 0xffffffff);
var x910: u32 = undefined;
var x911: u32 = undefined;
mulxU32(&x910, &x911, x878, 0xffffffff);
var x912: u32 = undefined;
var x913: u32 = undefined;
mulxU32(&x912, &x913, x878, 0xffffffff);
var x914: u32 = undefined;
var x915: u32 = undefined;
mulxU32(&x914, &x915, x878, 0xffffffff);
var x916: u32 = undefined;
var x917: u32 = undefined;
mulxU32(&x916, &x917, x878, 0xfffffffe);
var x918: u32 = undefined;
var x919: u32 = undefined;
mulxU32(&x918, &x919, x878, 0xffffffff);
var x920: u32 = undefined;
var x921: u32 = undefined;
mulxU32(&x920, &x921, x878, 0xffffffff);
var x922: u32 = undefined;
var x923: u1 = undefined;
addcarryxU32(&x922, &x923, 0x0, x919, x916);
var x924: u32 = undefined;
var x925: u1 = undefined;
addcarryxU32(&x924, &x925, x923, x917, x914);
var x926: u32 = undefined;
var x927: u1 = undefined;
addcarryxU32(&x926, &x927, x925, x915, x912);
var x928: u32 = undefined;
var x929: u1 = undefined;
addcarryxU32(&x928, &x929, x927, x913, x910);
var x930: u32 = undefined;
var x931: u1 = undefined;
addcarryxU32(&x930, &x931, x929, x911, x908);
var x932: u32 = undefined;
var x933: u1 = undefined;
addcarryxU32(&x932, &x933, x931, x909, x906);
var x934: u32 = undefined;
var x935: u1 = undefined;
addcarryxU32(&x934, &x935, x933, x907, x904);
var x936: u32 = undefined;
var x937: u1 = undefined;
addcarryxU32(&x936, &x937, x935, x905, x902);
var x938: u32 = undefined;
var x939: u1 = undefined;
addcarryxU32(&x938, &x939, 0x0, x878, x920);
var x940: u32 = undefined;
var x941: u1 = undefined;
addcarryxU32(&x940, &x941, x939, x880, x921);
var x942: u32 = undefined;
var x943: u1 = undefined;
addcarryxU32(&x942, &x943, x941, x882, cast(u32, 0x0));
var x944: u32 = undefined;
var x945: u1 = undefined;
addcarryxU32(&x944, &x945, x943, x884, x918);
var x946: u32 = undefined;
var x947: u1 = undefined;
addcarryxU32(&x946, &x947, x945, x886, x922);
var x948: u32 = undefined;
var x949: u1 = undefined;
addcarryxU32(&x948, &x949, x947, x888, x924);
var x950: u32 = undefined;
var x951: u1 = undefined;
addcarryxU32(&x950, &x951, x949, x890, x926);
var x952: u32 = undefined;
var x953: u1 = undefined;
addcarryxU32(&x952, &x953, x951, x892, x928);
var x954: u32 = undefined;
var x955: u1 = undefined;
addcarryxU32(&x954, &x955, x953, x894, x930);
var x956: u32 = undefined;
var x957: u1 = undefined;
addcarryxU32(&x956, &x957, x955, x896, x932);
var x958: u32 = undefined;
var x959: u1 = undefined;
addcarryxU32(&x958, &x959, x957, x898, x934);
var x960: u32 = undefined;
var x961: u1 = undefined;
addcarryxU32(&x960, &x961, x959, x900, x936);
var x962: u32 = undefined;
var x963: u1 = undefined;
addcarryxU32(&x962, &x963, x961, (cast(u32, x901) + cast(u32, x877)), (cast(u32, x937) + x903));
var x964: u32 = undefined;
var x965: u1 = undefined;
subborrowxU32(&x964, &x965, 0x0, x940, 0xffffffff);
var x966: u32 = undefined;
var x967: u1 = undefined;
subborrowxU32(&x966, &x967, x965, x942, cast(u32, 0x0));
var x968: u32 = undefined;
var x969: u1 = undefined;
subborrowxU32(&x968, &x969, x967, x944, cast(u32, 0x0));
var x970: u32 = undefined;
var x971: u1 = undefined;
subborrowxU32(&x970, &x971, x969, x946, 0xffffffff);
var x972: u32 = undefined;
var x973: u1 = undefined;
subborrowxU32(&x972, &x973, x971, x948, 0xfffffffe);
var x974: u32 = undefined;
var x975: u1 = undefined;
subborrowxU32(&x974, &x975, x973, x950, 0xffffffff);
var x976: u32 = undefined;
var x977: u1 = undefined;
subborrowxU32(&x976, &x977, x975, x952, 0xffffffff);
var x978: u32 = undefined;
var x979: u1 = undefined;
subborrowxU32(&x978, &x979, x977, x954, 0xffffffff);
var x980: u32 = undefined;
var x981: u1 = undefined;
subborrowxU32(&x980, &x981, x979, x956, 0xffffffff);
var x982: u32 = undefined;
var x983: u1 = undefined;
subborrowxU32(&x982, &x983, x981, x958, 0xffffffff);
var x984: u32 = undefined;
var x985: u1 = undefined;
subborrowxU32(&x984, &x985, x983, x960, 0xffffffff);
var x986: u32 = undefined;
var x987: u1 = undefined;
subborrowxU32(&x986, &x987, x985, x962, 0xffffffff);
var x988: u32 = undefined;
var x989: u1 = undefined;
subborrowxU32(&x988, &x989, x987, cast(u32, x963), cast(u32, 0x0));
var x990: u32 = undefined;
cmovznzU32(&x990, x989, x964, x940);
var x991: u32 = undefined;
cmovznzU32(&x991, x989, x966, x942);
var x992: u32 = undefined;
cmovznzU32(&x992, x989, x968, x944);
var x993: u32 = undefined;
cmovznzU32(&x993, x989, x970, x946);
var x994: u32 = undefined;
cmovznzU32(&x994, x989, x972, x948);
var x995: u32 = undefined;
cmovznzU32(&x995, x989, x974, x950);
var x996: u32 = undefined;
cmovznzU32(&x996, x989, x976, x952);
var x997: u32 = undefined;
cmovznzU32(&x997, x989, x978, x954);
var x998: u32 = undefined;
cmovznzU32(&x998, x989, x980, x956);
var x999: u32 = undefined;
cmovznzU32(&x999, x989, x982, x958);
var x1000: u32 = undefined;
cmovznzU32(&x1000, x989, x984, x960);
var x1001: u32 = undefined;
cmovznzU32(&x1001, x989, x986, x962);
out1[0] = x990;
out1[1] = x991;
out1[2] = x992;
out1[3] = x993;
out1[4] = x994;
out1[5] = x995;
out1[6] = x996;
out1[7] = x997;
out1[8] = x998;
out1[9] = x999;
out1[10] = x1000;
out1[11] = x1001;
}
/// The function toMontgomery translates a field element into the Montgomery domain.
///
/// Preconditions:
/// 0 ≤ eval arg1 < m
/// Postconditions:
/// eval (from_montgomery out1) mod m = eval arg1 mod m
/// 0 ≤ eval out1 < m
///
pub fn toMontgomery(out1: *MontgomeryDomainFieldElement, arg1: NonMontgomeryDomainFieldElement) void {
@setRuntimeSafety(mode == .Debug);
const x1 = (arg1[1]);
const x2 = (arg1[2]);
const x3 = (arg1[3]);
const x4 = (arg1[4]);
const x5 = (arg1[5]);
const x6 = (arg1[6]);
const x7 = (arg1[7]);
const x8 = (arg1[8]);
const x9 = (arg1[9]);
const x10 = (arg1[10]);
const x11 = (arg1[11]);
const x12 = (arg1[0]);
var x13: u32 = undefined;
var x14: u32 = undefined;
mulxU32(&x13, &x14, x12, 0x2);
var x15: u32 = undefined;
var x16: u32 = undefined;
mulxU32(&x15, &x16, x12, 0xfffffffe);
var x17: u32 = undefined;
var x18: u32 = undefined;
mulxU32(&x17, &x18, x12, 0x2);
var x19: u32 = undefined;
var x20: u32 = undefined;
mulxU32(&x19, &x20, x12, 0xfffffffe);
var x21: u32 = undefined;
var x22: u1 = undefined;
addcarryxU32(&x21, &x22, 0x0, cast(u32, cast(u1, x14)), x12);
var x23: u32 = undefined;
var x24: u32 = undefined;
mulxU32(&x23, &x24, x12, 0xffffffff);
var x25: u32 = undefined;
var x26: u32 = undefined;
mulxU32(&x25, &x26, x12, 0xffffffff);
var x27: u32 = undefined;
var x28: u32 = undefined;
mulxU32(&x27, &x28, x12, 0xffffffff);
var x29: u32 = undefined;
var x30: u32 = undefined;
mulxU32(&x29, &x30, x12, 0xffffffff);
var x31: u32 = undefined;
var x32: u32 = undefined;
mulxU32(&x31, &x32, x12, 0xffffffff);
var x33: u32 = undefined;
var x34: u32 = undefined;
mulxU32(&x33, &x34, x12, 0xffffffff);
var x35: u32 = undefined;
var x36: u32 = undefined;
mulxU32(&x35, &x36, x12, 0xffffffff);
var x37: u32 = undefined;
var x38: u32 = undefined;
mulxU32(&x37, &x38, x12, 0xfffffffe);
var x39: u32 = undefined;
var x40: u32 = undefined;
mulxU32(&x39, &x40, x12, 0xffffffff);
var x41: u32 = undefined;
var x42: u32 = undefined;
mulxU32(&x41, &x42, x12, 0xffffffff);
var x43: u32 = undefined;
var x44: u1 = undefined;
addcarryxU32(&x43, &x44, 0x0, x40, x37);
var x45: u32 = undefined;
var x46: u1 = undefined;
addcarryxU32(&x45, &x46, x44, x38, x35);
var x47: u32 = undefined;
var x48: u1 = undefined;
addcarryxU32(&x47, &x48, x46, x36, x33);
var x49: u32 = undefined;
var x50: u1 = undefined;
addcarryxU32(&x49, &x50, x48, x34, x31);
var x51: u32 = undefined;
var x52: u1 = undefined;
addcarryxU32(&x51, &x52, x50, x32, x29);
var x53: u32 = undefined;
var x54: u1 = undefined;
addcarryxU32(&x53, &x54, x52, x30, x27);
var x55: u32 = undefined;
var x56: u1 = undefined;
addcarryxU32(&x55, &x56, x54, x28, x25);
var x57: u32 = undefined;
var x58: u1 = undefined;
addcarryxU32(&x57, &x58, x56, x26, x23);
var x59: u32 = undefined;
var x60: u1 = undefined;
addcarryxU32(&x59, &x60, 0x0, x12, x41);
var x61: u32 = undefined;
var x62: u1 = undefined;
addcarryxU32(&x61, &x62, x60, x19, x42);
var x63: u32 = undefined;
var x64: u1 = undefined;
addcarryxU32(&x63, &x64, 0x0, x17, x39);
var x65: u32 = undefined;
var x66: u1 = undefined;
addcarryxU32(&x65, &x66, x64, cast(u32, cast(u1, x18)), x43);
var x67: u32 = undefined;
var x68: u1 = undefined;
addcarryxU32(&x67, &x68, x66, x15, x45);
var x69: u32 = undefined;
var x70: u1 = undefined;
addcarryxU32(&x69, &x70, x68, x16, x47);
var x71: u32 = undefined;
var x72: u1 = undefined;
addcarryxU32(&x71, &x72, x70, x13, x49);
var x73: u32 = undefined;
var x74: u1 = undefined;
addcarryxU32(&x73, &x74, x72, x21, x51);
var x75: u32 = undefined;
var x76: u1 = undefined;
addcarryxU32(&x75, &x76, x74, cast(u32, x22), x53);
var x77: u32 = undefined;
var x78: u1 = undefined;
addcarryxU32(&x77, &x78, x76, cast(u32, 0x0), x55);
var x79: u32 = undefined;
var x80: u1 = undefined;
addcarryxU32(&x79, &x80, x78, cast(u32, 0x0), x57);
var x81: u32 = undefined;
var x82: u1 = undefined;
addcarryxU32(&x81, &x82, x80, cast(u32, 0x0), (cast(u32, x58) + x24));
var x83: u32 = undefined;
var x84: u32 = undefined;
mulxU32(&x83, &x84, x1, 0x2);
var x85: u32 = undefined;
var x86: u32 = undefined;
mulxU32(&x85, &x86, x1, 0xfffffffe);
var x87: u32 = undefined;
var x88: u32 = undefined;
mulxU32(&x87, &x88, x1, 0x2);
var x89: u32 = undefined;
var x90: u32 = undefined;
mulxU32(&x89, &x90, x1, 0xfffffffe);
var x91: u32 = undefined;
var x92: u1 = undefined;
addcarryxU32(&x91, &x92, 0x0, cast(u32, cast(u1, x84)), x1);
var x93: u32 = undefined;
var x94: u1 = undefined;
addcarryxU32(&x93, &x94, 0x0, x61, x1);
var x95: u32 = undefined;
var x96: u1 = undefined;
addcarryxU32(&x95, &x96, x94, (cast(u32, x62) + x20), x89);
var x97: u32 = undefined;
var x98: u1 = undefined;
addcarryxU32(&x97, &x98, x96, x63, x90);
var x99: u32 = undefined;
var x100: u1 = undefined;
addcarryxU32(&x99, &x100, x98, x65, x87);
var x101: u32 = undefined;
var x102: u1 = undefined;
addcarryxU32(&x101, &x102, x100, x67, cast(u32, cast(u1, x88)));
var x103: u32 = undefined;
var x104: u1 = undefined;
addcarryxU32(&x103, &x104, x102, x69, x85);
var x105: u32 = undefined;
var x106: u1 = undefined;
addcarryxU32(&x105, &x106, x104, x71, x86);
var x107: u32 = undefined;
var x108: u1 = undefined;
addcarryxU32(&x107, &x108, x106, x73, x83);
var x109: u32 = undefined;
var x110: u1 = undefined;
addcarryxU32(&x109, &x110, x108, x75, x91);
var x111: u32 = undefined;
var x112: u1 = undefined;
addcarryxU32(&x111, &x112, x110, x77, cast(u32, x92));
var x113: u32 = undefined;
var x114: u1 = undefined;
addcarryxU32(&x113, &x114, x112, x79, cast(u32, 0x0));
var x115: u32 = undefined;
var x116: u1 = undefined;
addcarryxU32(&x115, &x116, x114, x81, cast(u32, 0x0));
var x117: u32 = undefined;
var x118: u32 = undefined;
mulxU32(&x117, &x118, x93, 0xffffffff);
var x119: u32 = undefined;
var x120: u32 = undefined;
mulxU32(&x119, &x120, x93, 0xffffffff);
var x121: u32 = undefined;
var x122: u32 = undefined;
mulxU32(&x121, &x122, x93, 0xffffffff);
var x123: u32 = undefined;
var x124: u32 = undefined;
mulxU32(&x123, &x124, x93, 0xffffffff);
var x125: u32 = undefined;
var x126: u32 = undefined;
mulxU32(&x125, &x126, x93, 0xffffffff);
var x127: u32 = undefined;
var x128: u32 = undefined;
mulxU32(&x127, &x128, x93, 0xffffffff);
var x129: u32 = undefined;
var x130: u32 = undefined;
mulxU32(&x129, &x130, x93, 0xffffffff);
var x131: u32 = undefined;
var x132: u32 = undefined;
mulxU32(&x131, &x132, x93, 0xfffffffe);
var x133: u32 = undefined;
var x134: u32 = undefined;
mulxU32(&x133, &x134, x93, 0xffffffff);
var x135: u32 = undefined;
var x136: u32 = undefined;
mulxU32(&x135, &x136, x93, 0xffffffff);
var x137: u32 = undefined;
var x138: u1 = undefined;
addcarryxU32(&x137, &x138, 0x0, x134, x131);
var x139: u32 = undefined;
var x140: u1 = undefined;
addcarryxU32(&x139, &x140, x138, x132, x129);
var x141: u32 = undefined;
var x142: u1 = undefined;
addcarryxU32(&x141, &x142, x140, x130, x127);
var x143: u32 = undefined;
var x144: u1 = undefined;
addcarryxU32(&x143, &x144, x142, x128, x125);
var x145: u32 = undefined;
var x146: u1 = undefined;
addcarryxU32(&x145, &x146, x144, x126, x123);
var x147: u32 = undefined;
var x148: u1 = undefined;
addcarryxU32(&x147, &x148, x146, x124, x121);
var x149: u32 = undefined;
var x150: u1 = undefined;
addcarryxU32(&x149, &x150, x148, x122, x119);
var x151: u32 = undefined;
var x152: u1 = undefined;
addcarryxU32(&x151, &x152, x150, x120, x117);
var x153: u32 = undefined;
var x154: u1 = undefined;
addcarryxU32(&x153, &x154, 0x0, x93, x135);
var x155: u32 = undefined;
var x156: u1 = undefined;
addcarryxU32(&x155, &x156, x154, x95, x136);
var x157: u32 = undefined;
var x158: u1 = undefined;
addcarryxU32(&x157, &x158, x156, x97, cast(u32, 0x0));
var x159: u32 = undefined;
var x160: u1 = undefined;
addcarryxU32(&x159, &x160, x158, x99, x133);
var x161: u32 = undefined;
var x162: u1 = undefined;
addcarryxU32(&x161, &x162, x160, x101, x137);
var x163: u32 = undefined;
var x164: u1 = undefined;
addcarryxU32(&x163, &x164, x162, x103, x139);
var x165: u32 = undefined;
var x166: u1 = undefined;
addcarryxU32(&x165, &x166, x164, x105, x141);
var x167: u32 = undefined;
var x168: u1 = undefined;
addcarryxU32(&x167, &x168, x166, x107, x143);
var x169: u32 = undefined;
var x170: u1 = undefined;
addcarryxU32(&x169, &x170, x168, x109, x145);
var x171: u32 = undefined;
var x172: u1 = undefined;
addcarryxU32(&x171, &x172, x170, x111, x147);
var x173: u32 = undefined;
var x174: u1 = undefined;
addcarryxU32(&x173, &x174, x172, x113, x149);
var x175: u32 = undefined;
var x176: u1 = undefined;
addcarryxU32(&x175, &x176, x174, x115, x151);
var x177: u32 = undefined;
var x178: u1 = undefined;
addcarryxU32(&x177, &x178, x176, (cast(u32, x116) + cast(u32, x82)), (cast(u32, x152) + x118));
var x179: u32 = undefined;
var x180: u32 = undefined;
mulxU32(&x179, &x180, x2, 0x2);
var x181: u32 = undefined;
var x182: u32 = undefined;
mulxU32(&x181, &x182, x2, 0xfffffffe);
var x183: u32 = undefined;
var x184: u32 = undefined;
mulxU32(&x183, &x184, x2, 0x2);
var x185: u32 = undefined;
var x186: u32 = undefined;
mulxU32(&x185, &x186, x2, 0xfffffffe);
var x187: u32 = undefined;
var x188: u1 = undefined;
addcarryxU32(&x187, &x188, 0x0, cast(u32, cast(u1, x180)), x2);
var x189: u32 = undefined;
var x190: u1 = undefined;
addcarryxU32(&x189, &x190, 0x0, x155, x2);
var x191: u32 = undefined;
var x192: u1 = undefined;
addcarryxU32(&x191, &x192, x190, x157, x185);
var x193: u32 = undefined;
var x194: u1 = undefined;
addcarryxU32(&x193, &x194, x192, x159, x186);
var x195: u32 = undefined;
var x196: u1 = undefined;
addcarryxU32(&x195, &x196, x194, x161, x183);
var x197: u32 = undefined;
var x198: u1 = undefined;
addcarryxU32(&x197, &x198, x196, x163, cast(u32, cast(u1, x184)));
var x199: u32 = undefined;
var x200: u1 = undefined;
addcarryxU32(&x199, &x200, x198, x165, x181);
var x201: u32 = undefined;
var x202: u1 = undefined;
addcarryxU32(&x201, &x202, x200, x167, x182);
var x203: u32 = undefined;
var x204: u1 = undefined;
addcarryxU32(&x203, &x204, x202, x169, x179);
var x205: u32 = undefined;
var x206: u1 = undefined;
addcarryxU32(&x205, &x206, x204, x171, x187);
var x207: u32 = undefined;
var x208: u1 = undefined;
addcarryxU32(&x207, &x208, x206, x173, cast(u32, x188));
var x209: u32 = undefined;
var x210: u1 = undefined;
addcarryxU32(&x209, &x210, x208, x175, cast(u32, 0x0));
var x211: u32 = undefined;
var x212: u1 = undefined;
addcarryxU32(&x211, &x212, x210, x177, cast(u32, 0x0));
var x213: u32 = undefined;
var x214: u32 = undefined;
mulxU32(&x213, &x214, x189, 0xffffffff);
var x215: u32 = undefined;
var x216: u32 = undefined;
mulxU32(&x215, &x216, x189, 0xffffffff);
var x217: u32 = undefined;
var x218: u32 = undefined;
mulxU32(&x217, &x218, x189, 0xffffffff);
var x219: u32 = undefined;
var x220: u32 = undefined;
mulxU32(&x219, &x220, x189, 0xffffffff);
var x221: u32 = undefined;
var x222: u32 = undefined;
mulxU32(&x221, &x222, x189, 0xffffffff);
var x223: u32 = undefined;
var x224: u32 = undefined;
mulxU32(&x223, &x224, x189, 0xffffffff);
var x225: u32 = undefined;
var x226: u32 = undefined;
mulxU32(&x225, &x226, x189, 0xffffffff);
var x227: u32 = undefined;
var x228: u32 = undefined;
mulxU32(&x227, &x228, x189, 0xfffffffe);
var x229: u32 = undefined;
var x230: u32 = undefined;
mulxU32(&x229, &x230, x189, 0xffffffff);
var x231: u32 = undefined;
var x232: u32 = undefined;
mulxU32(&x231, &x232, x189, 0xffffffff);
var x233: u32 = undefined;
var x234: u1 = undefined;
addcarryxU32(&x233, &x234, 0x0, x230, x227);
var x235: u32 = undefined;
var x236: u1 = undefined;
addcarryxU32(&x235, &x236, x234, x228, x225);
var x237: u32 = undefined;
var x238: u1 = undefined;
addcarryxU32(&x237, &x238, x236, x226, x223);
var x239: u32 = undefined;
var x240: u1 = undefined;
addcarryxU32(&x239, &x240, x238, x224, x221);
var x241: u32 = undefined;
var x242: u1 = undefined;
addcarryxU32(&x241, &x242, x240, x222, x219);
var x243: u32 = undefined;
var x244: u1 = undefined;
addcarryxU32(&x243, &x244, x242, x220, x217);
var x245: u32 = undefined;
var x246: u1 = undefined;
addcarryxU32(&x245, &x246, x244, x218, x215);
var x247: u32 = undefined;
var x248: u1 = undefined;
addcarryxU32(&x247, &x248, x246, x216, x213);
var x249: u32 = undefined;
var x250: u1 = undefined;
addcarryxU32(&x249, &x250, 0x0, x189, x231);
var x251: u32 = undefined;
var x252: u1 = undefined;
addcarryxU32(&x251, &x252, x250, x191, x232);
var x253: u32 = undefined;
var x254: u1 = undefined;
addcarryxU32(&x253, &x254, x252, x193, cast(u32, 0x0));
var x255: u32 = undefined;
var x256: u1 = undefined;
addcarryxU32(&x255, &x256, x254, x195, x229);
var x257: u32 = undefined;
var x258: u1 = undefined;
addcarryxU32(&x257, &x258, x256, x197, x233);
var x259: u32 = undefined;
var x260: u1 = undefined;
addcarryxU32(&x259, &x260, x258, x199, x235);
var x261: u32 = undefined;
var x262: u1 = undefined;
addcarryxU32(&x261, &x262, x260, x201, x237);
var x263: u32 = undefined;
var x264: u1 = undefined;
addcarryxU32(&x263, &x264, x262, x203, x239);
var x265: u32 = undefined;
var x266: u1 = undefined;
addcarryxU32(&x265, &x266, x264, x205, x241);
var x267: u32 = undefined;
var x268: u1 = undefined;
addcarryxU32(&x267, &x268, x266, x207, x243);
var x269: u32 = undefined;
var x270: u1 = undefined;
addcarryxU32(&x269, &x270, x268, x209, x245);
var x271: u32 = undefined;
var x272: u1 = undefined;
addcarryxU32(&x271, &x272, x270, x211, x247);
var x273: u32 = undefined;
var x274: u1 = undefined;
addcarryxU32(&x273, &x274, x272, (cast(u32, x212) + cast(u32, x178)), (cast(u32, x248) + x214));
var x275: u32 = undefined;
var x276: u32 = undefined;
mulxU32(&x275, &x276, x3, 0x2);
var x277: u32 = undefined;
var x278: u32 = undefined;
mulxU32(&x277, &x278, x3, 0xfffffffe);
var x279: u32 = undefined;
var x280: u32 = undefined;
mulxU32(&x279, &x280, x3, 0x2);
var x281: u32 = undefined;
var x282: u32 = undefined;
mulxU32(&x281, &x282, x3, 0xfffffffe);
var x283: u32 = undefined;
var x284: u1 = undefined;
addcarryxU32(&x283, &x284, 0x0, cast(u32, cast(u1, x276)), x3);
var x285: u32 = undefined;
var x286: u1 = undefined;
addcarryxU32(&x285, &x286, 0x0, x251, x3);
var x287: u32 = undefined;
var x288: u1 = undefined;
addcarryxU32(&x287, &x288, x286, x253, x281);
var x289: u32 = undefined;
var x290: u1 = undefined;
addcarryxU32(&x289, &x290, x288, x255, x282);
var x291: u32 = undefined;
var x292: u1 = undefined;
addcarryxU32(&x291, &x292, x290, x257, x279);
var x293: u32 = undefined;
var x294: u1 = undefined;
addcarryxU32(&x293, &x294, x292, x259, cast(u32, cast(u1, x280)));
var x295: u32 = undefined;
var x296: u1 = undefined;
addcarryxU32(&x295, &x296, x294, x261, x277);
var x297: u32 = undefined;
var x298: u1 = undefined;
addcarryxU32(&x297, &x298, x296, x263, x278);
var x299: u32 = undefined;
var x300: u1 = undefined;
addcarryxU32(&x299, &x300, x298, x265, x275);
var x301: u32 = undefined;
var x302: u1 = undefined;
addcarryxU32(&x301, &x302, x300, x267, x283);
var x303: u32 = undefined;
var x304: u1 = undefined;
addcarryxU32(&x303, &x304, x302, x269, cast(u32, x284));
var x305: u32 = undefined;
var x306: u1 = undefined;
addcarryxU32(&x305, &x306, x304, x271, cast(u32, 0x0));
var x307: u32 = undefined;
var x308: u1 = undefined;
addcarryxU32(&x307, &x308, x306, x273, cast(u32, 0x0));
var x309: u32 = undefined;
var x310: u32 = undefined;
mulxU32(&x309, &x310, x285, 0xffffffff);
var x311: u32 = undefined;
var x312: u32 = undefined;
mulxU32(&x311, &x312, x285, 0xffffffff);
var x313: u32 = undefined;
var x314: u32 = undefined;
mulxU32(&x313, &x314, x285, 0xffffffff);
var x315: u32 = undefined;
var x316: u32 = undefined;
mulxU32(&x315, &x316, x285, 0xffffffff);
var x317: u32 = undefined;
var x318: u32 = undefined;
mulxU32(&x317, &x318, x285, 0xffffffff);
var x319: u32 = undefined;
var x320: u32 = undefined;
mulxU32(&x319, &x320, x285, 0xffffffff);
var x321: u32 = undefined;
var x322: u32 = undefined;
mulxU32(&x321, &x322, x285, 0xffffffff);
var x323: u32 = undefined;
var x324: u32 = undefined;
mulxU32(&x323, &x324, x285, 0xfffffffe);
var x325: u32 = undefined;
var x326: u32 = undefined;
mulxU32(&x325, &x326, x285, 0xffffffff);
var x327: u32 = undefined;
var x328: u32 = undefined;
mulxU32(&x327, &x328, x285, 0xffffffff);
var x329: u32 = undefined;
var x330: u1 = undefined;
addcarryxU32(&x329, &x330, 0x0, x326, x323);
var x331: u32 = undefined;
var x332: u1 = undefined;
addcarryxU32(&x331, &x332, x330, x324, x321);
var x333: u32 = undefined;
var x334: u1 = undefined;
addcarryxU32(&x333, &x334, x332, x322, x319);
var x335: u32 = undefined;
var x336: u1 = undefined;
addcarryxU32(&x335, &x336, x334, x320, x317);
var x337: u32 = undefined;
var x338: u1 = undefined;
addcarryxU32(&x337, &x338, x336, x318, x315);
var x339: u32 = undefined;
var x340: u1 = undefined;
addcarryxU32(&x339, &x340, x338, x316, x313);
var x341: u32 = undefined;
var x342: u1 = undefined;
addcarryxU32(&x341, &x342, x340, x314, x311);
var x343: u32 = undefined;
var x344: u1 = undefined;
addcarryxU32(&x343, &x344, x342, x312, x309);
var x345: u32 = undefined;
var x346: u1 = undefined;
addcarryxU32(&x345, &x346, 0x0, x285, x327);
var x347: u32 = undefined;
var x348: u1 = undefined;
addcarryxU32(&x347, &x348, x346, x287, x328);
var x349: u32 = undefined;
var x350: u1 = undefined;
addcarryxU32(&x349, &x350, x348, x289, cast(u32, 0x0));
var x351: u32 = undefined;
var x352: u1 = undefined;
addcarryxU32(&x351, &x352, x350, x291, x325);
var x353: u32 = undefined;
var x354: u1 = undefined;
addcarryxU32(&x353, &x354, x352, x293, x329);
var x355: u32 = undefined;
var x356: u1 = undefined;
addcarryxU32(&x355, &x356, x354, x295, x331);
var x357: u32 = undefined;
var x358: u1 = undefined;
addcarryxU32(&x357, &x358, x356, x297, x333);
var x359: u32 = undefined;
var x360: u1 = undefined;
addcarryxU32(&x359, &x360, x358, x299, x335);
var x361: u32 = undefined;
var x362: u1 = undefined;
addcarryxU32(&x361, &x362, x360, x301, x337);
var x363: u32 = undefined;
var x364: u1 = undefined;
addcarryxU32(&x363, &x364, x362, x303, x339);
var x365: u32 = undefined;
var x366: u1 = undefined;
addcarryxU32(&x365, &x366, x364, x305, x341);
var x367: u32 = undefined;
var x368: u1 = undefined;
addcarryxU32(&x367, &x368, x366, x307, x343);
var x369: u32 = undefined;
var x370: u1 = undefined;
addcarryxU32(&x369, &x370, x368, (cast(u32, x308) + cast(u32, x274)), (cast(u32, x344) + x310));
var x371: u32 = undefined;
var x372: u32 = undefined;
mulxU32(&x371, &x372, x4, 0x2);
var x373: u32 = undefined;
var x374: u32 = undefined;
mulxU32(&x373, &x374, x4, 0xfffffffe);
var x375: u32 = undefined;
var x376: u32 = undefined;
mulxU32(&x375, &x376, x4, 0x2);
var x377: u32 = undefined;
var x378: u32 = undefined;
mulxU32(&x377, &x378, x4, 0xfffffffe);
var x379: u32 = undefined;
var x380: u1 = undefined;
addcarryxU32(&x379, &x380, 0x0, cast(u32, cast(u1, x372)), x4);
var x381: u32 = undefined;
var x382: u1 = undefined;
addcarryxU32(&x381, &x382, 0x0, x347, x4);
var x383: u32 = undefined;
var x384: u1 = undefined;
addcarryxU32(&x383, &x384, x382, x349, x377);
var x385: u32 = undefined;
var x386: u1 = undefined;
addcarryxU32(&x385, &x386, x384, x351, x378);
var x387: u32 = undefined;
var x388: u1 = undefined;
addcarryxU32(&x387, &x388, x386, x353, x375);
var x389: u32 = undefined;
var x390: u1 = undefined;
addcarryxU32(&x389, &x390, x388, x355, cast(u32, cast(u1, x376)));
var x391: u32 = undefined;
var x392: u1 = undefined;
addcarryxU32(&x391, &x392, x390, x357, x373);
var x393: u32 = undefined;
var x394: u1 = undefined;
addcarryxU32(&x393, &x394, x392, x359, x374);
var x395: u32 = undefined;
var x396: u1 = undefined;
addcarryxU32(&x395, &x396, x394, x361, x371);
var x397: u32 = undefined;
var x398: u1 = undefined;
addcarryxU32(&x397, &x398, x396, x363, x379);
var x399: u32 = undefined;
var x400: u1 = undefined;
addcarryxU32(&x399, &x400, x398, x365, cast(u32, x380));
var x401: u32 = undefined;
var x402: u1 = undefined;
addcarryxU32(&x401, &x402, x400, x367, cast(u32, 0x0));
var x403: u32 = undefined;
var x404: u1 = undefined;
addcarryxU32(&x403, &x404, x402, x369, cast(u32, 0x0));
var x405: u32 = undefined;
var x406: u32 = undefined;
mulxU32(&x405, &x406, x381, 0xffffffff);
var x407: u32 = undefined;
var x408: u32 = undefined;
mulxU32(&x407, &x408, x381, 0xffffffff);
var x409: u32 = undefined;
var x410: u32 = undefined;
mulxU32(&x409, &x410, x381, 0xffffffff);
var x411: u32 = undefined;
var x412: u32 = undefined;
mulxU32(&x411, &x412, x381, 0xffffffff);
var x413: u32 = undefined;
var x414: u32 = undefined;
mulxU32(&x413, &x414, x381, 0xffffffff);
var x415: u32 = undefined;
var x416: u32 = undefined;
mulxU32(&x415, &x416, x381, 0xffffffff);
var x417: u32 = undefined;
var x418: u32 = undefined;
mulxU32(&x417, &x418, x381, 0xffffffff);
var x419: u32 = undefined;
var x420: u32 = undefined;
mulxU32(&x419, &x420, x381, 0xfffffffe);
var x421: u32 = undefined;
var x422: u32 = undefined;
mulxU32(&x421, &x422, x381, 0xffffffff);
var x423: u32 = undefined;
var x424: u32 = undefined;
mulxU32(&x423, &x424, x381, 0xffffffff);
var x425: u32 = undefined;
var x426: u1 = undefined;
addcarryxU32(&x425, &x426, 0x0, x422, x419);
var x427: u32 = undefined;
var x428: u1 = undefined;
addcarryxU32(&x427, &x428, x426, x420, x417);
var x429: u32 = undefined;
var x430: u1 = undefined;
addcarryxU32(&x429, &x430, x428, x418, x415);
var x431: u32 = undefined;
var x432: u1 = undefined;
addcarryxU32(&x431, &x432, x430, x416, x413);
var x433: u32 = undefined;
var x434: u1 = undefined;
addcarryxU32(&x433, &x434, x432, x414, x411);
var x435: u32 = undefined;
var x436: u1 = undefined;
addcarryxU32(&x435, &x436, x434, x412, x409);
var x437: u32 = undefined;
var x438: u1 = undefined;
addcarryxU32(&x437, &x438, x436, x410, x407);
var x439: u32 = undefined;
var x440: u1 = undefined;
addcarryxU32(&x439, &x440, x438, x408, x405);
var x441: u32 = undefined;
var x442: u1 = undefined;
addcarryxU32(&x441, &x442, 0x0, x381, x423);
var x443: u32 = undefined;
var x444: u1 = undefined;
addcarryxU32(&x443, &x444, x442, x383, x424);
var x445: u32 = undefined;
var x446: u1 = undefined;
addcarryxU32(&x445, &x446, x444, x385, cast(u32, 0x0));
var x447: u32 = undefined;
var x448: u1 = undefined;
addcarryxU32(&x447, &x448, x446, x387, x421);
var x449: u32 = undefined;
var x450: u1 = undefined;
addcarryxU32(&x449, &x450, x448, x389, x425);
var x451: u32 = undefined;
var x452: u1 = undefined;
addcarryxU32(&x451, &x452, x450, x391, x427);
var x453: u32 = undefined;
var x454: u1 = undefined;
addcarryxU32(&x453, &x454, x452, x393, x429);
var x455: u32 = undefined;
var x456: u1 = undefined;
addcarryxU32(&x455, &x456, x454, x395, x431);
var x457: u32 = undefined;
var x458: u1 = undefined;
addcarryxU32(&x457, &x458, x456, x397, x433);
var x459: u32 = undefined;
var x460: u1 = undefined;
addcarryxU32(&x459, &x460, x458, x399, x435);
var x461: u32 = undefined;
var x462: u1 = undefined;
addcarryxU32(&x461, &x462, x460, x401, x437);
var x463: u32 = undefined;
var x464: u1 = undefined;
addcarryxU32(&x463, &x464, x462, x403, x439);
var x465: u32 = undefined;
var x466: u1 = undefined;
addcarryxU32(&x465, &x466, x464, (cast(u32, x404) + cast(u32, x370)), (cast(u32, x440) + x406));
var x467: u32 = undefined;
var x468: u32 = undefined;
mulxU32(&x467, &x468, x5, 0x2);
var x469: u32 = undefined;
var x470: u32 = undefined;
mulxU32(&x469, &x470, x5, 0xfffffffe);
var x471: u32 = undefined;
var x472: u32 = undefined;
mulxU32(&x471, &x472, x5, 0x2);
var x473: u32 = undefined;
var x474: u32 = undefined;
mulxU32(&x473, &x474, x5, 0xfffffffe);
var x475: u32 = undefined;
var x476: u1 = undefined;
addcarryxU32(&x475, &x476, 0x0, cast(u32, cast(u1, x468)), x5);
var x477: u32 = undefined;
var x478: u1 = undefined;
addcarryxU32(&x477, &x478, 0x0, x443, x5);
var x479: u32 = undefined;
var x480: u1 = undefined;
addcarryxU32(&x479, &x480, x478, x445, x473);
var x481: u32 = undefined;
var x482: u1 = undefined;
addcarryxU32(&x481, &x482, x480, x447, x474);
var x483: u32 = undefined;
var x484: u1 = undefined;
addcarryxU32(&x483, &x484, x482, x449, x471);
var x485: u32 = undefined;
var x486: u1 = undefined;
addcarryxU32(&x485, &x486, x484, x451, cast(u32, cast(u1, x472)));
var x487: u32 = undefined;
var x488: u1 = undefined;
addcarryxU32(&x487, &x488, x486, x453, x469);
var x489: u32 = undefined;
var x490: u1 = undefined;
addcarryxU32(&x489, &x490, x488, x455, x470);
var x491: u32 = undefined;
var x492: u1 = undefined;
addcarryxU32(&x491, &x492, x490, x457, x467);
var x493: u32 = undefined;
var x494: u1 = undefined;
addcarryxU32(&x493, &x494, x492, x459, x475);
var x495: u32 = undefined;
var x496: u1 = undefined;
addcarryxU32(&x495, &x496, x494, x461, cast(u32, x476));
var x497: u32 = undefined;
var x498: u1 = undefined;
addcarryxU32(&x497, &x498, x496, x463, cast(u32, 0x0));
var x499: u32 = undefined;
var x500: u1 = undefined;
addcarryxU32(&x499, &x500, x498, x465, cast(u32, 0x0));
var x501: u32 = undefined;
var x502: u32 = undefined;
mulxU32(&x501, &x502, x477, 0xffffffff);
var x503: u32 = undefined;
var x504: u32 = undefined;
mulxU32(&x503, &x504, x477, 0xffffffff);
var x505: u32 = undefined;
var x506: u32 = undefined;
mulxU32(&x505, &x506, x477, 0xffffffff);
var x507: u32 = undefined;
var x508: u32 = undefined;
mulxU32(&x507, &x508, x477, 0xffffffff);
var x509: u32 = undefined;
var x510: u32 = undefined;
mulxU32(&x509, &x510, x477, 0xffffffff);
var x511: u32 = undefined;
var x512: u32 = undefined;
mulxU32(&x511, &x512, x477, 0xffffffff);
var x513: u32 = undefined;
var x514: u32 = undefined;
mulxU32(&x513, &x514, x477, 0xffffffff);
var x515: u32 = undefined;
var x516: u32 = undefined;
mulxU32(&x515, &x516, x477, 0xfffffffe);
var x517: u32 = undefined;
var x518: u32 = undefined;
mulxU32(&x517, &x518, x477, 0xffffffff);
var x519: u32 = undefined;
var x520: u32 = undefined;
mulxU32(&x519, &x520, x477, 0xffffffff);
var x521: u32 = undefined;
var x522: u1 = undefined;
addcarryxU32(&x521, &x522, 0x0, x518, x515);
var x523: u32 = undefined;
var x524: u1 = undefined;
addcarryxU32(&x523, &x524, x522, x516, x513);
var x525: u32 = undefined;
var x526: u1 = undefined;
addcarryxU32(&x525, &x526, x524, x514, x511);
var x527: u32 = undefined;
var x528: u1 = undefined;
addcarryxU32(&x527, &x528, x526, x512, x509);
var x529: u32 = undefined;
var x530: u1 = undefined;
addcarryxU32(&x529, &x530, x528, x510, x507);
var x531: u32 = undefined;
var x532: u1 = undefined;
addcarryxU32(&x531, &x532, x530, x508, x505);
var x533: u32 = undefined;
var x534: u1 = undefined;
addcarryxU32(&x533, &x534, x532, x506, x503);
var x535: u32 = undefined;
var x536: u1 = undefined;
addcarryxU32(&x535, &x536, x534, x504, x501);
var x537: u32 = undefined;
var x538: u1 = undefined;
addcarryxU32(&x537, &x538, 0x0, x477, x519);
var x539: u32 = undefined;
var x540: u1 = undefined;
addcarryxU32(&x539, &x540, x538, x479, x520);
var x541: u32 = undefined;
var x542: u1 = undefined;
addcarryxU32(&x541, &x542, x540, x481, cast(u32, 0x0));
var x543: u32 = undefined;
var x544: u1 = undefined;
addcarryxU32(&x543, &x544, x542, x483, x517);
var x545: u32 = undefined;
var x546: u1 = undefined;
addcarryxU32(&x545, &x546, x544, x485, x521);
var x547: u32 = undefined;
var x548: u1 = undefined;
addcarryxU32(&x547, &x548, x546, x487, x523);
var x549: u32 = undefined;
var x550: u1 = undefined;
addcarryxU32(&x549, &x550, x548, x489, x525);
var x551: u32 = undefined;
var x552: u1 = undefined;
addcarryxU32(&x551, &x552, x550, x491, x527);
var x553: u32 = undefined;
var x554: u1 = undefined;
addcarryxU32(&x553, &x554, x552, x493, x529);
var x555: u32 = undefined;
var x556: u1 = undefined;
addcarryxU32(&x555, &x556, x554, x495, x531);
var x557: u32 = undefined;
var x558: u1 = undefined;
addcarryxU32(&x557, &x558, x556, x497, x533);
var x559: u32 = undefined;
var x560: u1 = undefined;
addcarryxU32(&x559, &x560, x558, x499, x535);
var x561: u32 = undefined;
var x562: u1 = undefined;
addcarryxU32(&x561, &x562, x560, (cast(u32, x500) + cast(u32, x466)), (cast(u32, x536) + x502));
var x563: u32 = undefined;
var x564: u32 = undefined;
mulxU32(&x563, &x564, x6, 0x2);
var x565: u32 = undefined;
var x566: u32 = undefined;
mulxU32(&x565, &x566, x6, 0xfffffffe);
var x567: u32 = undefined;
var x568: u32 = undefined;
mulxU32(&x567, &x568, x6, 0x2);
var x569: u32 = undefined;
var x570: u32 = undefined;
mulxU32(&x569, &x570, x6, 0xfffffffe);
var x571: u32 = undefined;
var x572: u1 = undefined;
addcarryxU32(&x571, &x572, 0x0, cast(u32, cast(u1, x564)), x6);
var x573: u32 = undefined;
var x574: u1 = undefined;
addcarryxU32(&x573, &x574, 0x0, x539, x6);
var x575: u32 = undefined;
var x576: u1 = undefined;
addcarryxU32(&x575, &x576, x574, x541, x569);
var x577: u32 = undefined;
var x578: u1 = undefined;
addcarryxU32(&x577, &x578, x576, x543, x570);
var x579: u32 = undefined;
var x580: u1 = undefined;
addcarryxU32(&x579, &x580, x578, x545, x567);
var x581: u32 = undefined;
var x582: u1 = undefined;
addcarryxU32(&x581, &x582, x580, x547, cast(u32, cast(u1, x568)));
var x583: u32 = undefined;
var x584: u1 = undefined;
addcarryxU32(&x583, &x584, x582, x549, x565);
var x585: u32 = undefined;
var x586: u1 = undefined;
addcarryxU32(&x585, &x586, x584, x551, x566);
var x587: u32 = undefined;
var x588: u1 = undefined;
addcarryxU32(&x587, &x588, x586, x553, x563);
var x589: u32 = undefined;
var x590: u1 = undefined;
addcarryxU32(&x589, &x590, x588, x555, x571);
var x591: u32 = undefined;
var x592: u1 = undefined;
addcarryxU32(&x591, &x592, x590, x557, cast(u32, x572));
var x593: u32 = undefined;
var x594: u1 = undefined;
addcarryxU32(&x593, &x594, x592, x559, cast(u32, 0x0));
var x595: u32 = undefined;
var x596: u1 = undefined;
addcarryxU32(&x595, &x596, x594, x561, cast(u32, 0x0));
var x597: u32 = undefined;
var x598: u32 = undefined;
mulxU32(&x597, &x598, x573, 0xffffffff);
var x599: u32 = undefined;
var x600: u32 = undefined;
mulxU32(&x599, &x600, x573, 0xffffffff);
var x601: u32 = undefined;
var x602: u32 = undefined;
mulxU32(&x601, &x602, x573, 0xffffffff);
var x603: u32 = undefined;
var x604: u32 = undefined;
mulxU32(&x603, &x604, x573, 0xffffffff);
var x605: u32 = undefined;
var x606: u32 = undefined;
mulxU32(&x605, &x606, x573, 0xffffffff);
var x607: u32 = undefined;
var x608: u32 = undefined;
mulxU32(&x607, &x608, x573, 0xffffffff);
var x609: u32 = undefined;
var x610: u32 = undefined;
mulxU32(&x609, &x610, x573, 0xffffffff);
var x611: u32 = undefined;
var x612: u32 = undefined;
mulxU32(&x611, &x612, x573, 0xfffffffe);
var x613: u32 = undefined;
var x614: u32 = undefined;
mulxU32(&x613, &x614, x573, 0xffffffff);
var x615: u32 = undefined;
var x616: u32 = undefined;
mulxU32(&x615, &x616, x573, 0xffffffff);
var x617: u32 = undefined;
var x618: u1 = undefined;
addcarryxU32(&x617, &x618, 0x0, x614, x611);
var x619: u32 = undefined;
var x620: u1 = undefined;
addcarryxU32(&x619, &x620, x618, x612, x609);
var x621: u32 = undefined;
var x622: u1 = undefined;
addcarryxU32(&x621, &x622, x620, x610, x607);
var x623: u32 = undefined;
var x624: u1 = undefined;
addcarryxU32(&x623, &x624, x622, x608, x605);
var x625: u32 = undefined;
var x626: u1 = undefined;
addcarryxU32(&x625, &x626, x624, x606, x603);
var x627: u32 = undefined;
var x628: u1 = undefined;
addcarryxU32(&x627, &x628, x626, x604, x601);
var x629: u32 = undefined;
var x630: u1 = undefined;
addcarryxU32(&x629, &x630, x628, x602, x599);
var x631: u32 = undefined;
var x632: u1 = undefined;
addcarryxU32(&x631, &x632, x630, x600, x597);
var x633: u32 = undefined;
var x634: u1 = undefined;
addcarryxU32(&x633, &x634, 0x0, x573, x615);
var x635: u32 = undefined;
var x636: u1 = undefined;
addcarryxU32(&x635, &x636, x634, x575, x616);
var x637: u32 = undefined;
var x638: u1 = undefined;
addcarryxU32(&x637, &x638, x636, x577, cast(u32, 0x0));
var x639: u32 = undefined;
var x640: u1 = undefined;
addcarryxU32(&x639, &x640, x638, x579, x613);
var x641: u32 = undefined;
var x642: u1 = undefined;
addcarryxU32(&x641, &x642, x640, x581, x617);
var x643: u32 = undefined;
var x644: u1 = undefined;
addcarryxU32(&x643, &x644, x642, x583, x619);
var x645: u32 = undefined;
var x646: u1 = undefined;
addcarryxU32(&x645, &x646, x644, x585, x621);
var x647: u32 = undefined;
var x648: u1 = undefined;
addcarryxU32(&x647, &x648, x646, x587, x623);
var x649: u32 = undefined;
var x650: u1 = undefined;
addcarryxU32(&x649, &x650, x648, x589, x625);
var x651: u32 = undefined;
var x652: u1 = undefined;
addcarryxU32(&x651, &x652, x650, x591, x627);
var x653: u32 = undefined;
var x654: u1 = undefined;
addcarryxU32(&x653, &x654, x652, x593, x629);
var x655: u32 = undefined;
var x656: u1 = undefined;
addcarryxU32(&x655, &x656, x654, x595, x631);
var x657: u32 = undefined;
var x658: u1 = undefined;
addcarryxU32(&x657, &x658, x656, (cast(u32, x596) + cast(u32, x562)), (cast(u32, x632) + x598));
var x659: u32 = undefined;
var x660: u32 = undefined;
mulxU32(&x659, &x660, x7, 0x2);
var x661: u32 = undefined;
var x662: u32 = undefined;
mulxU32(&x661, &x662, x7, 0xfffffffe);
var x663: u32 = undefined;
var x664: u32 = undefined;
mulxU32(&x663, &x664, x7, 0x2);
var x665: u32 = undefined;
var x666: u32 = undefined;
mulxU32(&x665, &x666, x7, 0xfffffffe);
var x667: u32 = undefined;
var x668: u1 = undefined;
addcarryxU32(&x667, &x668, 0x0, cast(u32, cast(u1, x660)), x7);
var x669: u32 = undefined;
var x670: u1 = undefined;
addcarryxU32(&x669, &x670, 0x0, x635, x7);
var x671: u32 = undefined;
var x672: u1 = undefined;
addcarryxU32(&x671, &x672, x670, x637, x665);
var x673: u32 = undefined;
var x674: u1 = undefined;
addcarryxU32(&x673, &x674, x672, x639, x666);
var x675: u32 = undefined;
var x676: u1 = undefined;
addcarryxU32(&x675, &x676, x674, x641, x663);
var x677: u32 = undefined;
var x678: u1 = undefined;
addcarryxU32(&x677, &x678, x676, x643, cast(u32, cast(u1, x664)));
var x679: u32 = undefined;
var x680: u1 = undefined;
addcarryxU32(&x679, &x680, x678, x645, x661);
var x681: u32 = undefined;
var x682: u1 = undefined;
addcarryxU32(&x681, &x682, x680, x647, x662);
var x683: u32 = undefined;
var x684: u1 = undefined;
addcarryxU32(&x683, &x684, x682, x649, x659);
var x685: u32 = undefined;
var x686: u1 = undefined;
addcarryxU32(&x685, &x686, x684, x651, x667);
var x687: u32 = undefined;
var x688: u1 = undefined;
addcarryxU32(&x687, &x688, x686, x653, cast(u32, x668));
var x689: u32 = undefined;
var x690: u1 = undefined;
addcarryxU32(&x689, &x690, x688, x655, cast(u32, 0x0));
var x691: u32 = undefined;
var x692: u1 = undefined;
addcarryxU32(&x691, &x692, x690, x657, cast(u32, 0x0));
var x693: u32 = undefined;
var x694: u32 = undefined;
mulxU32(&x693, &x694, x669, 0xffffffff);
var x695: u32 = undefined;
var x696: u32 = undefined;
mulxU32(&x695, &x696, x669, 0xffffffff);
var x697: u32 = undefined;
var x698: u32 = undefined;
mulxU32(&x697, &x698, x669, 0xffffffff);
var x699: u32 = undefined;
var x700: u32 = undefined;
mulxU32(&x699, &x700, x669, 0xffffffff);
var x701: u32 = undefined;
var x702: u32 = undefined;
mulxU32(&x701, &x702, x669, 0xffffffff);
var x703: u32 = undefined;
var x704: u32 = undefined;
mulxU32(&x703, &x704, x669, 0xffffffff);
var x705: u32 = undefined;
var x706: u32 = undefined;
mulxU32(&x705, &x706, x669, 0xffffffff);
var x707: u32 = undefined;
var x708: u32 = undefined;
mulxU32(&x707, &x708, x669, 0xfffffffe);
var x709: u32 = undefined;
var x710: u32 = undefined;
mulxU32(&x709, &x710, x669, 0xffffffff);
var x711: u32 = undefined;
var x712: u32 = undefined;
mulxU32(&x711, &x712, x669, 0xffffffff);
var x713: u32 = undefined;
var x714: u1 = undefined;
addcarryxU32(&x713, &x714, 0x0, x710, x707);
var x715: u32 = undefined;
var x716: u1 = undefined;
addcarryxU32(&x715, &x716, x714, x708, x705);
var x717: u32 = undefined;
var x718: u1 = undefined;
addcarryxU32(&x717, &x718, x716, x706, x703);
var x719: u32 = undefined;
var x720: u1 = undefined;
addcarryxU32(&x719, &x720, x718, x704, x701);
var x721: u32 = undefined;
var x722: u1 = undefined;
addcarryxU32(&x721, &x722, x720, x702, x699);
var x723: u32 = undefined;
var x724: u1 = undefined;
addcarryxU32(&x723, &x724, x722, x700, x697);
var x725: u32 = undefined;
var x726: u1 = undefined;
addcarryxU32(&x725, &x726, x724, x698, x695);
var x727: u32 = undefined;
var x728: u1 = undefined;
addcarryxU32(&x727, &x728, x726, x696, x693);
var x729: u32 = undefined;
var x730: u1 = undefined;
addcarryxU32(&x729, &x730, 0x0, x669, x711);
var x731: u32 = undefined;
var x732: u1 = undefined;
addcarryxU32(&x731, &x732, x730, x671, x712);
var x733: u32 = undefined;
var x734: u1 = undefined;
addcarryxU32(&x733, &x734, x732, x673, cast(u32, 0x0));
var x735: u32 = undefined;
var x736: u1 = undefined;
addcarryxU32(&x735, &x736, x734, x675, x709);
var x737: u32 = undefined;
var x738: u1 = undefined;
addcarryxU32(&x737, &x738, x736, x677, x713);
var x739: u32 = undefined;
var x740: u1 = undefined;
addcarryxU32(&x739, &x740, x738, x679, x715);
var x741: u32 = undefined;
var x742: u1 = undefined;
addcarryxU32(&x741, &x742, x740, x681, x717);
var x743: u32 = undefined;
var x744: u1 = undefined;
addcarryxU32(&x743, &x744, x742, x683, x719);
var x745: u32 = undefined;
var x746: u1 = undefined;
addcarryxU32(&x745, &x746, x744, x685, x721);
var x747: u32 = undefined;
var x748: u1 = undefined;
addcarryxU32(&x747, &x748, x746, x687, x723);
var x749: u32 = undefined;
var x750: u1 = undefined;
addcarryxU32(&x749, &x750, x748, x689, x725);
var x751: u32 = undefined;
var x752: u1 = undefined;
addcarryxU32(&x751, &x752, x750, x691, x727);
var x753: u32 = undefined;
var x754: u1 = undefined;
addcarryxU32(&x753, &x754, x752, (cast(u32, x692) + cast(u32, x658)), (cast(u32, x728) + x694));
var x755: u32 = undefined;
var x756: u32 = undefined;
mulxU32(&x755, &x756, x8, 0x2);
var x757: u32 = undefined;
var x758: u32 = undefined;
mulxU32(&x757, &x758, x8, 0xfffffffe);
var x759: u32 = undefined;
var x760: u32 = undefined;
mulxU32(&x759, &x760, x8, 0x2);
var x761: u32 = undefined;
var x762: u32 = undefined;
mulxU32(&x761, &x762, x8, 0xfffffffe);
var x763: u32 = undefined;
var x764: u1 = undefined;
addcarryxU32(&x763, &x764, 0x0, cast(u32, cast(u1, x756)), x8);
var x765: u32 = undefined;
var x766: u1 = undefined;
addcarryxU32(&x765, &x766, 0x0, x731, x8);
var x767: u32 = undefined;
var x768: u1 = undefined;
addcarryxU32(&x767, &x768, x766, x733, x761);
var x769: u32 = undefined;
var x770: u1 = undefined;
addcarryxU32(&x769, &x770, x768, x735, x762);
var x771: u32 = undefined;
var x772: u1 = undefined;
addcarryxU32(&x771, &x772, x770, x737, x759);
var x773: u32 = undefined;
var x774: u1 = undefined;
addcarryxU32(&x773, &x774, x772, x739, cast(u32, cast(u1, x760)));
var x775: u32 = undefined;
var x776: u1 = undefined;
addcarryxU32(&x775, &x776, x774, x741, x757);
var x777: u32 = undefined;
var x778: u1 = undefined;
addcarryxU32(&x777, &x778, x776, x743, x758);
var x779: u32 = undefined;
var x780: u1 = undefined;
addcarryxU32(&x779, &x780, x778, x745, x755);
var x781: u32 = undefined;
var x782: u1 = undefined;
addcarryxU32(&x781, &x782, x780, x747, x763);
var x783: u32 = undefined;
var x784: u1 = undefined;
addcarryxU32(&x783, &x784, x782, x749, cast(u32, x764));
var x785: u32 = undefined;
var x786: u1 = undefined;
addcarryxU32(&x785, &x786, x784, x751, cast(u32, 0x0));
var x787: u32 = undefined;
var x788: u1 = undefined;
addcarryxU32(&x787, &x788, x786, x753, cast(u32, 0x0));
var x789: u32 = undefined;
var x790: u32 = undefined;
mulxU32(&x789, &x790, x765, 0xffffffff);
var x791: u32 = undefined;
var x792: u32 = undefined;
mulxU32(&x791, &x792, x765, 0xffffffff);
var x793: u32 = undefined;
var x794: u32 = undefined;
mulxU32(&x793, &x794, x765, 0xffffffff);
var x795: u32 = undefined;
var x796: u32 = undefined;
mulxU32(&x795, &x796, x765, 0xffffffff);
var x797: u32 = undefined;
var x798: u32 = undefined;
mulxU32(&x797, &x798, x765, 0xffffffff);
var x799: u32 = undefined;
var x800: u32 = undefined;
mulxU32(&x799, &x800, x765, 0xffffffff);
var x801: u32 = undefined;
var x802: u32 = undefined;
mulxU32(&x801, &x802, x765, 0xffffffff);
var x803: u32 = undefined;
var x804: u32 = undefined;
mulxU32(&x803, &x804, x765, 0xfffffffe);
var x805: u32 = undefined;
var x806: u32 = undefined;
mulxU32(&x805, &x806, x765, 0xffffffff);
var x807: u32 = undefined;
var x808: u32 = undefined;
mulxU32(&x807, &x808, x765, 0xffffffff);
var x809: u32 = undefined;
var x810: u1 = undefined;
addcarryxU32(&x809, &x810, 0x0, x806, x803);
var x811: u32 = undefined;
var x812: u1 = undefined;
addcarryxU32(&x811, &x812, x810, x804, x801);
var x813: u32 = undefined;
var x814: u1 = undefined;
addcarryxU32(&x813, &x814, x812, x802, x799);
var x815: u32 = undefined;
var x816: u1 = undefined;
addcarryxU32(&x815, &x816, x814, x800, x797);
var x817: u32 = undefined;
var x818: u1 = undefined;
addcarryxU32(&x817, &x818, x816, x798, x795);
var x819: u32 = undefined;
var x820: u1 = undefined;
addcarryxU32(&x819, &x820, x818, x796, x793);
var x821: u32 = undefined;
var x822: u1 = undefined;
addcarryxU32(&x821, &x822, x820, x794, x791);
var x823: u32 = undefined;
var x824: u1 = undefined;
addcarryxU32(&x823, &x824, x822, x792, x789);
var x825: u32 = undefined;
var x826: u1 = undefined;
addcarryxU32(&x825, &x826, 0x0, x765, x807);
var x827: u32 = undefined;
var x828: u1 = undefined;
addcarryxU32(&x827, &x828, x826, x767, x808);
var x829: u32 = undefined;
var x830: u1 = undefined;
addcarryxU32(&x829, &x830, x828, x769, cast(u32, 0x0));
var x831: u32 = undefined;
var x832: u1 = undefined;
addcarryxU32(&x831, &x832, x830, x771, x805);
var x833: u32 = undefined;
var x834: u1 = undefined;
addcarryxU32(&x833, &x834, x832, x773, x809);
var x835: u32 = undefined;
var x836: u1 = undefined;
addcarryxU32(&x835, &x836, x834, x775, x811);
var x837: u32 = undefined;
var x838: u1 = undefined;
addcarryxU32(&x837, &x838, x836, x777, x813);
var x839: u32 = undefined;
var x840: u1 = undefined;
addcarryxU32(&x839, &x840, x838, x779, x815);
var x841: u32 = undefined;
var x842: u1 = undefined;
addcarryxU32(&x841, &x842, x840, x781, x817);
var x843: u32 = undefined;
var x844: u1 = undefined;
addcarryxU32(&x843, &x844, x842, x783, x819);
var x845: u32 = undefined;
var x846: u1 = undefined;
addcarryxU32(&x845, &x846, x844, x785, x821);
var x847: u32 = undefined;
var x848: u1 = undefined;
addcarryxU32(&x847, &x848, x846, x787, x823);
var x849: u32 = undefined;
var x850: u1 = undefined;
addcarryxU32(&x849, &x850, x848, (cast(u32, x788) + cast(u32, x754)), (cast(u32, x824) + x790));
var x851: u32 = undefined;
var x852: u32 = undefined;
mulxU32(&x851, &x852, x9, 0x2);
var x853: u32 = undefined;
var x854: u32 = undefined;
mulxU32(&x853, &x854, x9, 0xfffffffe);
var x855: u32 = undefined;
var x856: u32 = undefined;
mulxU32(&x855, &x856, x9, 0x2);
var x857: u32 = undefined;
var x858: u32 = undefined;
mulxU32(&x857, &x858, x9, 0xfffffffe);
var x859: u32 = undefined;
var x860: u1 = undefined;
addcarryxU32(&x859, &x860, 0x0, cast(u32, cast(u1, x852)), x9);
var x861: u32 = undefined;
var x862: u1 = undefined;
addcarryxU32(&x861, &x862, 0x0, x827, x9);
var x863: u32 = undefined;
var x864: u1 = undefined;
addcarryxU32(&x863, &x864, x862, x829, x857);
var x865: u32 = undefined;
var x866: u1 = undefined;
addcarryxU32(&x865, &x866, x864, x831, x858);
var x867: u32 = undefined;
var x868: u1 = undefined;
addcarryxU32(&x867, &x868, x866, x833, x855);
var x869: u32 = undefined;
var x870: u1 = undefined;
addcarryxU32(&x869, &x870, x868, x835, cast(u32, cast(u1, x856)));
var x871: u32 = undefined;
var x872: u1 = undefined;
addcarryxU32(&x871, &x872, x870, x837, x853);
var x873: u32 = undefined;
var x874: u1 = undefined;
addcarryxU32(&x873, &x874, x872, x839, x854);
var x875: u32 = undefined;
var x876: u1 = undefined;
addcarryxU32(&x875, &x876, x874, x841, x851);
var x877: u32 = undefined;
var x878: u1 = undefined;
addcarryxU32(&x877, &x878, x876, x843, x859);
var x879: u32 = undefined;
var x880: u1 = undefined;
addcarryxU32(&x879, &x880, x878, x845, cast(u32, x860));
var x881: u32 = undefined;
var x882: u1 = undefined;
addcarryxU32(&x881, &x882, x880, x847, cast(u32, 0x0));
var x883: u32 = undefined;
var x884: u1 = undefined;
addcarryxU32(&x883, &x884, x882, x849, cast(u32, 0x0));
var x885: u32 = undefined;
var x886: u32 = undefined;
mulxU32(&x885, &x886, x861, 0xffffffff);
var x887: u32 = undefined;
var x888: u32 = undefined;
mulxU32(&x887, &x888, x861, 0xffffffff);
var x889: u32 = undefined;
var x890: u32 = undefined;
mulxU32(&x889, &x890, x861, 0xffffffff);
var x891: u32 = undefined;
var x892: u32 = undefined;
mulxU32(&x891, &x892, x861, 0xffffffff);
var x893: u32 = undefined;
var x894: u32 = undefined;
mulxU32(&x893, &x894, x861, 0xffffffff);
var x895: u32 = undefined;
var x896: u32 = undefined;
mulxU32(&x895, &x896, x861, 0xffffffff);
var x897: u32 = undefined;
var x898: u32 = undefined;
mulxU32(&x897, &x898, x861, 0xffffffff);
var x899: u32 = undefined;
var x900: u32 = undefined;
mulxU32(&x899, &x900, x861, 0xfffffffe);
var x901: u32 = undefined;
var x902: u32 = undefined;
mulxU32(&x901, &x902, x861, 0xffffffff);
var x903: u32 = undefined;
var x904: u32 = undefined;
mulxU32(&x903, &x904, x861, 0xffffffff);
var x905: u32 = undefined;
var x906: u1 = undefined;
addcarryxU32(&x905, &x906, 0x0, x902, x899);
var x907: u32 = undefined;
var x908: u1 = undefined;
addcarryxU32(&x907, &x908, x906, x900, x897);
var x909: u32 = undefined;
var x910: u1 = undefined;
addcarryxU32(&x909, &x910, x908, x898, x895);
var x911: u32 = undefined;
var x912: u1 = undefined;
addcarryxU32(&x911, &x912, x910, x896, x893);
var x913: u32 = undefined;
var x914: u1 = undefined;
addcarryxU32(&x913, &x914, x912, x894, x891);
var x915: u32 = undefined;
var x916: u1 = undefined;
addcarryxU32(&x915, &x916, x914, x892, x889);
var x917: u32 = undefined;
var x918: u1 = undefined;
addcarryxU32(&x917, &x918, x916, x890, x887);
var x919: u32 = undefined;
var x920: u1 = undefined;
addcarryxU32(&x919, &x920, x918, x888, x885);
var x921: u32 = undefined;
var x922: u1 = undefined;
addcarryxU32(&x921, &x922, 0x0, x861, x903);
var x923: u32 = undefined;
var x924: u1 = undefined;
addcarryxU32(&x923, &x924, x922, x863, x904);
var x925: u32 = undefined;
var x926: u1 = undefined;
addcarryxU32(&x925, &x926, x924, x865, cast(u32, 0x0));
var x927: u32 = undefined;
var x928: u1 = undefined;
addcarryxU32(&x927, &x928, x926, x867, x901);
var x929: u32 = undefined;
var x930: u1 = undefined;
addcarryxU32(&x929, &x930, x928, x869, x905);
var x931: u32 = undefined;
var x932: u1 = undefined;
addcarryxU32(&x931, &x932, x930, x871, x907);
var x933: u32 = undefined;
var x934: u1 = undefined;
addcarryxU32(&x933, &x934, x932, x873, x909);
var x935: u32 = undefined;
var x936: u1 = undefined;
addcarryxU32(&x935, &x936, x934, x875, x911);
var x937: u32 = undefined;
var x938: u1 = undefined;
addcarryxU32(&x937, &x938, x936, x877, x913);
var x939: u32 = undefined;
var x940: u1 = undefined;
addcarryxU32(&x939, &x940, x938, x879, x915);
var x941: u32 = undefined;
var x942: u1 = undefined;
addcarryxU32(&x941, &x942, x940, x881, x917);
var x943: u32 = undefined;
var x944: u1 = undefined;
addcarryxU32(&x943, &x944, x942, x883, x919);
var x945: u32 = undefined;
var x946: u1 = undefined;
addcarryxU32(&x945, &x946, x944, (cast(u32, x884) + cast(u32, x850)), (cast(u32, x920) + x886));
var x947: u32 = undefined;
var x948: u32 = undefined;
mulxU32(&x947, &x948, x10, 0x2);
var x949: u32 = undefined;
var x950: u32 = undefined;
mulxU32(&x949, &x950, x10, 0xfffffffe);
var x951: u32 = undefined;
var x952: u32 = undefined;
mulxU32(&x951, &x952, x10, 0x2);
var x953: u32 = undefined;
var x954: u32 = undefined;
mulxU32(&x953, &x954, x10, 0xfffffffe);
var x955: u32 = undefined;
var x956: u1 = undefined;
addcarryxU32(&x955, &x956, 0x0, cast(u32, cast(u1, x948)), x10);
var x957: u32 = undefined;
var x958: u1 = undefined;
addcarryxU32(&x957, &x958, 0x0, x923, x10);
var x959: u32 = undefined;
var x960: u1 = undefined;
addcarryxU32(&x959, &x960, x958, x925, x953);
var x961: u32 = undefined;
var x962: u1 = undefined;
addcarryxU32(&x961, &x962, x960, x927, x954);
var x963: u32 = undefined;
var x964: u1 = undefined;
addcarryxU32(&x963, &x964, x962, x929, x951);
var x965: u32 = undefined;
var x966: u1 = undefined;
addcarryxU32(&x965, &x966, x964, x931, cast(u32, cast(u1, x952)));
var x967: u32 = undefined;
var x968: u1 = undefined;
addcarryxU32(&x967, &x968, x966, x933, x949);
var x969: u32 = undefined;
var x970: u1 = undefined;
addcarryxU32(&x969, &x970, x968, x935, x950);
var x971: u32 = undefined;
var x972: u1 = undefined;
addcarryxU32(&x971, &x972, x970, x937, x947);
var x973: u32 = undefined;
var x974: u1 = undefined;
addcarryxU32(&x973, &x974, x972, x939, x955);
var x975: u32 = undefined;
var x976: u1 = undefined;
addcarryxU32(&x975, &x976, x974, x941, cast(u32, x956));
var x977: u32 = undefined;
var x978: u1 = undefined;
addcarryxU32(&x977, &x978, x976, x943, cast(u32, 0x0));
var x979: u32 = undefined;
var x980: u1 = undefined;
addcarryxU32(&x979, &x980, x978, x945, cast(u32, 0x0));
var x981: u32 = undefined;
var x982: u32 = undefined;
mulxU32(&x981, &x982, x957, 0xffffffff);
var x983: u32 = undefined;
var x984: u32 = undefined;
mulxU32(&x983, &x984, x957, 0xffffffff);
var x985: u32 = undefined;
var x986: u32 = undefined;
mulxU32(&x985, &x986, x957, 0xffffffff);
var x987: u32 = undefined;
var x988: u32 = undefined;
mulxU32(&x987, &x988, x957, 0xffffffff);
var x989: u32 = undefined;
var x990: u32 = undefined;
mulxU32(&x989, &x990, x957, 0xffffffff);
var x991: u32 = undefined;
var x992: u32 = undefined;
mulxU32(&x991, &x992, x957, 0xffffffff);
var x993: u32 = undefined;
var x994: u32 = undefined;
mulxU32(&x993, &x994, x957, 0xffffffff);
var x995: u32 = undefined;
var x996: u32 = undefined;
mulxU32(&x995, &x996, x957, 0xfffffffe);
var x997: u32 = undefined;
var x998: u32 = undefined;
mulxU32(&x997, &x998, x957, 0xffffffff);
var x999: u32 = undefined;
var x1000: u32 = undefined;
mulxU32(&x999, &x1000, x957, 0xffffffff);
var x1001: u32 = undefined;
var x1002: u1 = undefined;
addcarryxU32(&x1001, &x1002, 0x0, x998, x995);
var x1003: u32 = undefined;
var x1004: u1 = undefined;
addcarryxU32(&x1003, &x1004, x1002, x996, x993);
var x1005: u32 = undefined;
var x1006: u1 = undefined;
addcarryxU32(&x1005, &x1006, x1004, x994, x991);
var x1007: u32 = undefined;
var x1008: u1 = undefined;
addcarryxU32(&x1007, &x1008, x1006, x992, x989);
var x1009: u32 = undefined;
var x1010: u1 = undefined;
addcarryxU32(&x1009, &x1010, x1008, x990, x987);
var x1011: u32 = undefined;
var x1012: u1 = undefined;
addcarryxU32(&x1011, &x1012, x1010, x988, x985);
var x1013: u32 = undefined;
var x1014: u1 = undefined;
addcarryxU32(&x1013, &x1014, x1012, x986, x983);
var x1015: u32 = undefined;
var x1016: u1 = undefined;
addcarryxU32(&x1015, &x1016, x1014, x984, x981);
var x1017: u32 = undefined;
var x1018: u1 = undefined;
addcarryxU32(&x1017, &x1018, 0x0, x957, x999);
var x1019: u32 = undefined;
var x1020: u1 = undefined;
addcarryxU32(&x1019, &x1020, x1018, x959, x1000);
var x1021: u32 = undefined;
var x1022: u1 = undefined;
addcarryxU32(&x1021, &x1022, x1020, x961, cast(u32, 0x0));
var x1023: u32 = undefined;
var x1024: u1 = undefined;
addcarryxU32(&x1023, &x1024, x1022, x963, x997);
var x1025: u32 = undefined;
var x1026: u1 = undefined;
addcarryxU32(&x1025, &x1026, x1024, x965, x1001);
var x1027: u32 = undefined;
var x1028: u1 = undefined;
addcarryxU32(&x1027, &x1028, x1026, x967, x1003);
var x1029: u32 = undefined;
var x1030: u1 = undefined;
addcarryxU32(&x1029, &x1030, x1028, x969, x1005);
var x1031: u32 = undefined;
var x1032: u1 = undefined;
addcarryxU32(&x1031, &x1032, x1030, x971, x1007);
var x1033: u32 = undefined;
var x1034: u1 = undefined;
addcarryxU32(&x1033, &x1034, x1032, x973, x1009);
var x1035: u32 = undefined;
var x1036: u1 = undefined;
addcarryxU32(&x1035, &x1036, x1034, x975, x1011);
var x1037: u32 = undefined;
var x1038: u1 = undefined;
addcarryxU32(&x1037, &x1038, x1036, x977, x1013);
var x1039: u32 = undefined;
var x1040: u1 = undefined;
addcarryxU32(&x1039, &x1040, x1038, x979, x1015);
var x1041: u32 = undefined;
var x1042: u1 = undefined;
addcarryxU32(&x1041, &x1042, x1040, (cast(u32, x980) + cast(u32, x946)), (cast(u32, x1016) + x982));
var x1043: u32 = undefined;
var x1044: u32 = undefined;
mulxU32(&x1043, &x1044, x11, 0x2);
var x1045: u32 = undefined;
var x1046: u32 = undefined;
mulxU32(&x1045, &x1046, x11, 0xfffffffe);
var x1047: u32 = undefined;
var x1048: u32 = undefined;
mulxU32(&x1047, &x1048, x11, 0x2);
var x1049: u32 = undefined;
var x1050: u32 = undefined;
mulxU32(&x1049, &x1050, x11, 0xfffffffe);
var x1051: u32 = undefined;
var x1052: u1 = undefined;
addcarryxU32(&x1051, &x1052, 0x0, cast(u32, cast(u1, x1044)), x11);
var x1053: u32 = undefined;
var x1054: u1 = undefined;
addcarryxU32(&x1053, &x1054, 0x0, x1019, x11);
var x1055: u32 = undefined;
var x1056: u1 = undefined;
addcarryxU32(&x1055, &x1056, x1054, x1021, x1049);
var x1057: u32 = undefined;
var x1058: u1 = undefined;
addcarryxU32(&x1057, &x1058, x1056, x1023, x1050);
var x1059: u32 = undefined;
var x1060: u1 = undefined;
addcarryxU32(&x1059, &x1060, x1058, x1025, x1047);
var x1061: u32 = undefined;
var x1062: u1 = undefined;
addcarryxU32(&x1061, &x1062, x1060, x1027, cast(u32, cast(u1, x1048)));
var x1063: u32 = undefined;
var x1064: u1 = undefined;
addcarryxU32(&x1063, &x1064, x1062, x1029, x1045);
var x1065: u32 = undefined;
var x1066: u1 = undefined;
addcarryxU32(&x1065, &x1066, x1064, x1031, x1046);
var x1067: u32 = undefined;
var x1068: u1 = undefined;
addcarryxU32(&x1067, &x1068, x1066, x1033, x1043);
var x1069: u32 = undefined;
var x1070: u1 = undefined;
addcarryxU32(&x1069, &x1070, x1068, x1035, x1051);
var x1071: u32 = undefined;
var x1072: u1 = undefined;
addcarryxU32(&x1071, &x1072, x1070, x1037, cast(u32, x1052));
var x1073: u32 = undefined;
var x1074: u1 = undefined;
addcarryxU32(&x1073, &x1074, x1072, x1039, cast(u32, 0x0));
var x1075: u32 = undefined;
var x1076: u1 = undefined;
addcarryxU32(&x1075, &x1076, x1074, x1041, cast(u32, 0x0));
var x1077: u32 = undefined;
var x1078: u32 = undefined;
mulxU32(&x1077, &x1078, x1053, 0xffffffff);
var x1079: u32 = undefined;
var x1080: u32 = undefined;
mulxU32(&x1079, &x1080, x1053, 0xffffffff);
var x1081: u32 = undefined;
var x1082: u32 = undefined;
mulxU32(&x1081, &x1082, x1053, 0xffffffff);
var x1083: u32 = undefined;
var x1084: u32 = undefined;
mulxU32(&x1083, &x1084, x1053, 0xffffffff);
var x1085: u32 = undefined;
var x1086: u32 = undefined;
mulxU32(&x1085, &x1086, x1053, 0xffffffff);
var x1087: u32 = undefined;
var x1088: u32 = undefined;
mulxU32(&x1087, &x1088, x1053, 0xffffffff);
var x1089: u32 = undefined;
var x1090: u32 = undefined;
mulxU32(&x1089, &x1090, x1053, 0xffffffff);
var x1091: u32 = undefined;
var x1092: u32 = undefined;
mulxU32(&x1091, &x1092, x1053, 0xfffffffe);
var x1093: u32 = undefined;
var x1094: u32 = undefined;
mulxU32(&x1093, &x1094, x1053, 0xffffffff);
var x1095: u32 = undefined;
var x1096: u32 = undefined;
mulxU32(&x1095, &x1096, x1053, 0xffffffff);
var x1097: u32 = undefined;
var x1098: u1 = undefined;
addcarryxU32(&x1097, &x1098, 0x0, x1094, x1091);
var x1099: u32 = undefined;
var x1100: u1 = undefined;
addcarryxU32(&x1099, &x1100, x1098, x1092, x1089);
var x1101: u32 = undefined;
var x1102: u1 = undefined;
addcarryxU32(&x1101, &x1102, x1100, x1090, x1087);
var x1103: u32 = undefined;
var x1104: u1 = undefined;
addcarryxU32(&x1103, &x1104, x1102, x1088, x1085);
var x1105: u32 = undefined;
var x1106: u1 = undefined;
addcarryxU32(&x1105, &x1106, x1104, x1086, x1083);
var x1107: u32 = undefined;
var x1108: u1 = undefined;
addcarryxU32(&x1107, &x1108, x1106, x1084, x1081);
var x1109: u32 = undefined;
var x1110: u1 = undefined;
addcarryxU32(&x1109, &x1110, x1108, x1082, x1079);
var x1111: u32 = undefined;
var x1112: u1 = undefined;
addcarryxU32(&x1111, &x1112, x1110, x1080, x1077);
var x1113: u32 = undefined;
var x1114: u1 = undefined;
addcarryxU32(&x1113, &x1114, 0x0, x1053, x1095);
var x1115: u32 = undefined;
var x1116: u1 = undefined;
addcarryxU32(&x1115, &x1116, x1114, x1055, x1096);
var x1117: u32 = undefined;
var x1118: u1 = undefined;
addcarryxU32(&x1117, &x1118, x1116, x1057, cast(u32, 0x0));
var x1119: u32 = undefined;
var x1120: u1 = undefined;
addcarryxU32(&x1119, &x1120, x1118, x1059, x1093);
var x1121: u32 = undefined;
var x1122: u1 = undefined;
addcarryxU32(&x1121, &x1122, x1120, x1061, x1097);
var x1123: u32 = undefined;
var x1124: u1 = undefined;
addcarryxU32(&x1123, &x1124, x1122, x1063, x1099);
var x1125: u32 = undefined;
var x1126: u1 = undefined;
addcarryxU32(&x1125, &x1126, x1124, x1065, x1101);
var x1127: u32 = undefined;
var x1128: u1 = undefined;
addcarryxU32(&x1127, &x1128, x1126, x1067, x1103);
var x1129: u32 = undefined;
var x1130: u1 = undefined;
addcarryxU32(&x1129, &x1130, x1128, x1069, x1105);
var x1131: u32 = undefined;
var x1132: u1 = undefined;
addcarryxU32(&x1131, &x1132, x1130, x1071, x1107);
var x1133: u32 = undefined;
var x1134: u1 = undefined;
addcarryxU32(&x1133, &x1134, x1132, x1073, x1109);
var x1135: u32 = undefined;
var x1136: u1 = undefined;
addcarryxU32(&x1135, &x1136, x1134, x1075, x1111);
var x1137: u32 = undefined;
var x1138: u1 = undefined;
addcarryxU32(&x1137, &x1138, x1136, (cast(u32, x1076) + cast(u32, x1042)), (cast(u32, x1112) + x1078));
var x1139: u32 = undefined;
var x1140: u1 = undefined;
subborrowxU32(&x1139, &x1140, 0x0, x1115, 0xffffffff);
var x1141: u32 = undefined;
var x1142: u1 = undefined;
subborrowxU32(&x1141, &x1142, x1140, x1117, cast(u32, 0x0));
var x1143: u32 = undefined;
var x1144: u1 = undefined;
subborrowxU32(&x1143, &x1144, x1142, x1119, cast(u32, 0x0));
var x1145: u32 = undefined;
var x1146: u1 = undefined;
subborrowxU32(&x1145, &x1146, x1144, x1121, 0xffffffff);
var x1147: u32 = undefined;
var x1148: u1 = undefined;
subborrowxU32(&x1147, &x1148, x1146, x1123, 0xfffffffe);
var x1149: u32 = undefined;
var x1150: u1 = undefined;
subborrowxU32(&x1149, &x1150, x1148, x1125, 0xffffffff);
var x1151: u32 = undefined;
var x1152: u1 = undefined;
subborrowxU32(&x1151, &x1152, x1150, x1127, 0xffffffff);
var x1153: u32 = undefined;
var x1154: u1 = undefined;
subborrowxU32(&x1153, &x1154, x1152, x1129, 0xffffffff);
var x1155: u32 = undefined;
var x1156: u1 = undefined;
subborrowxU32(&x1155, &x1156, x1154, x1131, 0xffffffff);
var x1157: u32 = undefined;
var x1158: u1 = undefined;
subborrowxU32(&x1157, &x1158, x1156, x1133, 0xffffffff);
var x1159: u32 = undefined;
var x1160: u1 = undefined;
subborrowxU32(&x1159, &x1160, x1158, x1135, 0xffffffff);
var x1161: u32 = undefined;
var x1162: u1 = undefined;
subborrowxU32(&x1161, &x1162, x1160, x1137, 0xffffffff);
var x1163: u32 = undefined;
var x1164: u1 = undefined;
subborrowxU32(&x1163, &x1164, x1162, cast(u32, x1138), cast(u32, 0x0));
var x1165: u32 = undefined;
cmovznzU32(&x1165, x1164, x1139, x1115);
var x1166: u32 = undefined;
cmovznzU32(&x1166, x1164, x1141, x1117);
var x1167: u32 = undefined;
cmovznzU32(&x1167, x1164, x1143, x1119);
var x1168: u32 = undefined;
cmovznzU32(&x1168, x1164, x1145, x1121);
var x1169: u32 = undefined;
cmovznzU32(&x1169, x1164, x1147, x1123);
var x1170: u32 = undefined;
cmovznzU32(&x1170, x1164, x1149, x1125);
var x1171: u32 = undefined;
cmovznzU32(&x1171, x1164, x1151, x1127);
var x1172: u32 = undefined;
cmovznzU32(&x1172, x1164, x1153, x1129);
var x1173: u32 = undefined;
cmovznzU32(&x1173, x1164, x1155, x1131);
var x1174: u32 = undefined;
cmovznzU32(&x1174, x1164, x1157, x1133);
var x1175: u32 = undefined;
cmovznzU32(&x1175, x1164, x1159, x1135);
var x1176: u32 = undefined;
cmovznzU32(&x1176, x1164, x1161, x1137);
out1[0] = x1165;
out1[1] = x1166;
out1[2] = x1167;
out1[3] = x1168;
out1[4] = x1169;
out1[5] = x1170;
out1[6] = x1171;
out1[7] = x1172;
out1[8] = x1173;
out1[9] = x1174;
out1[10] = x1175;
out1[11] = x1176;
}
/// The function nonzero outputs a single non-zero word if the input is non-zero and zero otherwise.
///
/// Preconditions:
/// 0 ≤ eval arg1 < m
/// Postconditions:
/// out1 = 0 ↔ eval (from_montgomery arg1) mod m = 0
///
/// Input Bounds:
/// arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]
/// Output Bounds:
/// out1: [0x0 ~> 0xffffffff]
pub fn nonzero(out1: *u32, arg1: [12]u32) void {
@setRuntimeSafety(mode == .Debug);
const x1 = ((arg1[0]) | ((arg1[1]) | ((arg1[2]) | ((arg1[3]) | ((arg1[4]) | ((arg1[5]) | ((arg1[6]) | ((arg1[7]) | ((arg1[8]) | ((arg1[9]) | ((arg1[10]) | (arg1[11]))))))))))));
out1.* = x1;
}
/// The function selectznz is a multi-limb conditional select.
///
/// Postconditions:
/// eval out1 = (if arg1 = 0 then eval arg2 else eval arg3)
///
/// Input Bounds:
/// arg1: [0x0 ~> 0x1]
/// arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]
/// arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]
/// Output Bounds:
/// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]
pub fn selectznz(out1: *[12]u32, arg1: u1, arg2: [12]u32, arg3: [12]u32) void {
@setRuntimeSafety(mode == .Debug);
var x1: u32 = undefined;
cmovznzU32(&x1, arg1, (arg2[0]), (arg3[0]));
var x2: u32 = undefined;
cmovznzU32(&x2, arg1, (arg2[1]), (arg3[1]));
var x3: u32 = undefined;
cmovznzU32(&x3, arg1, (arg2[2]), (arg3[2]));
var x4: u32 = undefined;
cmovznzU32(&x4, arg1, (arg2[3]), (arg3[3]));
var x5: u32 = undefined;
cmovznzU32(&x5, arg1, (arg2[4]), (arg3[4]));
var x6: u32 = undefined;
cmovznzU32(&x6, arg1, (arg2[5]), (arg3[5]));
var x7: u32 = undefined;
cmovznzU32(&x7, arg1, (arg2[6]), (arg3[6]));
var x8: u32 = undefined;
cmovznzU32(&x8, arg1, (arg2[7]), (arg3[7]));
var x9: u32 = undefined;
cmovznzU32(&x9, arg1, (arg2[8]), (arg3[8]));
var x10: u32 = undefined;
cmovznzU32(&x10, arg1, (arg2[9]), (arg3[9]));
var x11: u32 = undefined;
cmovznzU32(&x11, arg1, (arg2[10]), (arg3[10]));
var x12: u32 = undefined;
cmovznzU32(&x12, arg1, (arg2[11]), (arg3[11]));
out1[0] = x1;
out1[1] = x2;
out1[2] = x3;
out1[3] = x4;
out1[4] = x5;
out1[5] = x6;
out1[6] = x7;
out1[7] = x8;
out1[8] = x9;
out1[9] = x10;
out1[10] = x11;
out1[11] = x12;
}
/// The function toBytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order.
///
/// Preconditions:
/// 0 ≤ eval arg1 < m
/// Postconditions:
/// out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..47]
///
/// Input Bounds:
/// arg1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]
/// Output Bounds:
/// out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]]
pub fn toBytes(out1: *[48]u8, arg1: [12]u32) void {
@setRuntimeSafety(mode == .Debug);
const x1 = (arg1[11]);
const x2 = (arg1[10]);
const x3 = (arg1[9]);
const x4 = (arg1[8]);
const x5 = (arg1[7]);
const x6 = (arg1[6]);
const x7 = (arg1[5]);
const x8 = (arg1[4]);
const x9 = (arg1[3]);
const x10 = (arg1[2]);
const x11 = (arg1[1]);
const x12 = (arg1[0]);
const x13 = cast(u8, (x12 & cast(u32, 0xff)));
const x14 = (x12 >> 8);
const x15 = cast(u8, (x14 & cast(u32, 0xff)));
const x16 = (x14 >> 8);
const x17 = cast(u8, (x16 & cast(u32, 0xff)));
const x18 = cast(u8, (x16 >> 8));
const x19 = cast(u8, (x11 & cast(u32, 0xff)));
const x20 = (x11 >> 8);
const x21 = cast(u8, (x20 & cast(u32, 0xff)));
const x22 = (x20 >> 8);
const x23 = cast(u8, (x22 & cast(u32, 0xff)));
const x24 = cast(u8, (x22 >> 8));
const x25 = cast(u8, (x10 & cast(u32, 0xff)));
const x26 = (x10 >> 8);
const x27 = cast(u8, (x26 & cast(u32, 0xff)));
const x28 = (x26 >> 8);
const x29 = cast(u8, (x28 & cast(u32, 0xff)));
const x30 = cast(u8, (x28 >> 8));
const x31 = cast(u8, (x9 & cast(u32, 0xff)));
const x32 = (x9 >> 8);
const x33 = cast(u8, (x32 & cast(u32, 0xff)));
const x34 = (x32 >> 8);
const x35 = cast(u8, (x34 & cast(u32, 0xff)));
const x36 = cast(u8, (x34 >> 8));
const x37 = cast(u8, (x8 & cast(u32, 0xff)));
const x38 = (x8 >> 8);
const x39 = cast(u8, (x38 & cast(u32, 0xff)));
const x40 = (x38 >> 8);
const x41 = cast(u8, (x40 & cast(u32, 0xff)));
const x42 = cast(u8, (x40 >> 8));
const x43 = cast(u8, (x7 & cast(u32, 0xff)));
const x44 = (x7 >> 8);
const x45 = cast(u8, (x44 & cast(u32, 0xff)));
const x46 = (x44 >> 8);
const x47 = cast(u8, (x46 & cast(u32, 0xff)));
const x48 = cast(u8, (x46 >> 8));
const x49 = cast(u8, (x6 & cast(u32, 0xff)));
const x50 = (x6 >> 8);
const x51 = cast(u8, (x50 & cast(u32, 0xff)));
const x52 = (x50 >> 8);
const x53 = cast(u8, (x52 & cast(u32, 0xff)));
const x54 = cast(u8, (x52 >> 8));
const x55 = cast(u8, (x5 & cast(u32, 0xff)));
const x56 = (x5 >> 8);
const x57 = cast(u8, (x56 & cast(u32, 0xff)));
const x58 = (x56 >> 8);
const x59 = cast(u8, (x58 & cast(u32, 0xff)));
const x60 = cast(u8, (x58 >> 8));
const x61 = cast(u8, (x4 & cast(u32, 0xff)));
const x62 = (x4 >> 8);
const x63 = cast(u8, (x62 & cast(u32, 0xff)));
const x64 = (x62 >> 8);
const x65 = cast(u8, (x64 & cast(u32, 0xff)));
const x66 = cast(u8, (x64 >> 8));
const x67 = cast(u8, (x3 & cast(u32, 0xff)));
const x68 = (x3 >> 8);
const x69 = cast(u8, (x68 & cast(u32, 0xff)));
const x70 = (x68 >> 8);
const x71 = cast(u8, (x70 & cast(u32, 0xff)));
const x72 = cast(u8, (x70 >> 8));
const x73 = cast(u8, (x2 & cast(u32, 0xff)));
const x74 = (x2 >> 8);
const x75 = cast(u8, (x74 & cast(u32, 0xff)));
const x76 = (x74 >> 8);
const x77 = cast(u8, (x76 & cast(u32, 0xff)));
const x78 = cast(u8, (x76 >> 8));
const x79 = cast(u8, (x1 & cast(u32, 0xff)));
const x80 = (x1 >> 8);
const x81 = cast(u8, (x80 & cast(u32, 0xff)));
const x82 = (x80 >> 8);
const x83 = cast(u8, (x82 & cast(u32, 0xff)));
const x84 = cast(u8, (x82 >> 8));
out1[0] = x13;
out1[1] = x15;
out1[2] = x17;
out1[3] = x18;
out1[4] = x19;
out1[5] = x21;
out1[6] = x23;
out1[7] = x24;
out1[8] = x25;
out1[9] = x27;
out1[10] = x29;
out1[11] = x30;
out1[12] = x31;
out1[13] = x33;
out1[14] = x35;
out1[15] = x36;
out1[16] = x37;
out1[17] = x39;
out1[18] = x41;
out1[19] = x42;
out1[20] = x43;
out1[21] = x45;
out1[22] = x47;
out1[23] = x48;
out1[24] = x49;
out1[25] = x51;
out1[26] = x53;
out1[27] = x54;
out1[28] = x55;
out1[29] = x57;
out1[30] = x59;
out1[31] = x60;
out1[32] = x61;
out1[33] = x63;
out1[34] = x65;
out1[35] = x66;
out1[36] = x67;
out1[37] = x69;
out1[38] = x71;
out1[39] = x72;
out1[40] = x73;
out1[41] = x75;
out1[42] = x77;
out1[43] = x78;
out1[44] = x79;
out1[45] = x81;
out1[46] = x83;
out1[47] = x84;
}
/// The function fromBytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order.
///
/// Preconditions:
/// 0 ≤ bytes_eval arg1 < m
/// Postconditions:
/// eval out1 mod m = bytes_eval arg1 mod m
/// 0 ≤ eval out1 < m
///
/// Input Bounds:
/// arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]]
/// Output Bounds:
/// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]
pub fn fromBytes(out1: *[12]u32, arg1: [48]u8) void {
@setRuntimeSafety(mode == .Debug);
const x1 = (cast(u32, (arg1[47])) << 24);
const x2 = (cast(u32, (arg1[46])) << 16);
const x3 = (cast(u32, (arg1[45])) << 8);
const x4 = (arg1[44]);
const x5 = (cast(u32, (arg1[43])) << 24);
const x6 = (cast(u32, (arg1[42])) << 16);
const x7 = (cast(u32, (arg1[41])) << 8);
const x8 = (arg1[40]);
const x9 = (cast(u32, (arg1[39])) << 24);
const x10 = (cast(u32, (arg1[38])) << 16);
const x11 = (cast(u32, (arg1[37])) << 8);
const x12 = (arg1[36]);
const x13 = (cast(u32, (arg1[35])) << 24);
const x14 = (cast(u32, (arg1[34])) << 16);
const x15 = (cast(u32, (arg1[33])) << 8);
const x16 = (arg1[32]);
const x17 = (cast(u32, (arg1[31])) << 24);
const x18 = (cast(u32, (arg1[30])) << 16);
const x19 = (cast(u32, (arg1[29])) << 8);
const x20 = (arg1[28]);
const x21 = (cast(u32, (arg1[27])) << 24);
const x22 = (cast(u32, (arg1[26])) << 16);
const x23 = (cast(u32, (arg1[25])) << 8);
const x24 = (arg1[24]);
const x25 = (cast(u32, (arg1[23])) << 24);
const x26 = (cast(u32, (arg1[22])) << 16);
const x27 = (cast(u32, (arg1[21])) << 8);
const x28 = (arg1[20]);
const x29 = (cast(u32, (arg1[19])) << 24);
const x30 = (cast(u32, (arg1[18])) << 16);
const x31 = (cast(u32, (arg1[17])) << 8);
const x32 = (arg1[16]);
const x33 = (cast(u32, (arg1[15])) << 24);
const x34 = (cast(u32, (arg1[14])) << 16);
const x35 = (cast(u32, (arg1[13])) << 8);
const x36 = (arg1[12]);
const x37 = (cast(u32, (arg1[11])) << 24);
const x38 = (cast(u32, (arg1[10])) << 16);
const x39 = (cast(u32, (arg1[9])) << 8);
const x40 = (arg1[8]);
const x41 = (cast(u32, (arg1[7])) << 24);
const x42 = (cast(u32, (arg1[6])) << 16);
const x43 = (cast(u32, (arg1[5])) << 8);
const x44 = (arg1[4]);
const x45 = (cast(u32, (arg1[3])) << 24);
const x46 = (cast(u32, (arg1[2])) << 16);
const x47 = (cast(u32, (arg1[1])) << 8);
const x48 = (arg1[0]);
const x49 = (x47 + cast(u32, x48));
const x50 = (x46 + x49);
const x51 = (x45 + x50);
const x52 = (x43 + cast(u32, x44));
const x53 = (x42 + x52);
const x54 = (x41 + x53);
const x55 = (x39 + cast(u32, x40));
const x56 = (x38 + x55);
const x57 = (x37 + x56);
const x58 = (x35 + cast(u32, x36));
const x59 = (x34 + x58);
const x60 = (x33 + x59);
const x61 = (x31 + cast(u32, x32));
const x62 = (x30 + x61);
const x63 = (x29 + x62);
const x64 = (x27 + cast(u32, x28));
const x65 = (x26 + x64);
const x66 = (x25 + x65);
const x67 = (x23 + cast(u32, x24));
const x68 = (x22 + x67);
const x69 = (x21 + x68);
const x70 = (x19 + cast(u32, x20));
const x71 = (x18 + x70);
const x72 = (x17 + x71);
const x73 = (x15 + cast(u32, x16));
const x74 = (x14 + x73);
const x75 = (x13 + x74);
const x76 = (x11 + cast(u32, x12));
const x77 = (x10 + x76);
const x78 = (x9 + x77);
const x79 = (x7 + cast(u32, x8));
const x80 = (x6 + x79);
const x81 = (x5 + x80);
const x82 = (x3 + cast(u32, x4));
const x83 = (x2 + x82);
const x84 = (x1 + x83);
out1[0] = x51;
out1[1] = x54;
out1[2] = x57;
out1[3] = x60;
out1[4] = x63;
out1[5] = x66;
out1[6] = x69;
out1[7] = x72;
out1[8] = x75;
out1[9] = x78;
out1[10] = x81;
out1[11] = x84;
}
/// The function setOne returns the field element one in the Montgomery domain.
///
/// Postconditions:
/// eval (from_montgomery out1) mod m = 1 mod m
/// 0 ≤ eval out1 < m
///
pub fn setOne(out1: *MontgomeryDomainFieldElement) void {
@setRuntimeSafety(mode == .Debug);
out1[0] = cast(u32, 0x1);
out1[1] = 0xffffffff;
out1[2] = 0xffffffff;
out1[3] = cast(u32, 0x0);
out1[4] = cast(u32, 0x1);
out1[5] = cast(u32, 0x0);
out1[6] = cast(u32, 0x0);
out1[7] = cast(u32, 0x0);
out1[8] = cast(u32, 0x0);
out1[9] = cast(u32, 0x0);
out1[10] = cast(u32, 0x0);
out1[11] = cast(u32, 0x0);
}
/// The function msat returns the saturated representation of the prime modulus.
///
/// Postconditions:
/// twos_complement_eval out1 = m
/// 0 ≤ eval out1 < m
///
/// Output Bounds:
/// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]
pub fn msat(out1: *[13]u32) void {
@setRuntimeSafety(mode == .Debug);
out1[0] = 0xffffffff;
out1[1] = cast(u32, 0x0);
out1[2] = cast(u32, 0x0);
out1[3] = 0xffffffff;
out1[4] = 0xfffffffe;
out1[5] = 0xffffffff;
out1[6] = 0xffffffff;
out1[7] = 0xffffffff;
out1[8] = 0xffffffff;
out1[9] = 0xffffffff;
out1[10] = 0xffffffff;
out1[11] = 0xffffffff;
out1[12] = cast(u32, 0x0);
}
/// The function divstep computes a divstep.
///
/// Preconditions:
/// 0 ≤ eval arg4 < m
/// 0 ≤ eval arg5 < m
/// Postconditions:
/// out1 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then 1 - arg1 else 1 + arg1)
/// twos_complement_eval out2 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then twos_complement_eval arg3 else twos_complement_eval arg2)
/// twos_complement_eval out3 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then ⌊(twos_complement_eval arg3 - twos_complement_eval arg2) / 2⌋ else ⌊(twos_complement_eval arg3 + (twos_complement_eval arg3 mod 2) * twos_complement_eval arg2) / 2⌋)
/// eval (from_montgomery out4) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (2 * eval (from_montgomery arg5)) mod m else (2 * eval (from_montgomery arg4)) mod m)
/// eval (from_montgomery out5) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (eval (from_montgomery arg4) - eval (from_montgomery arg4)) mod m else (eval (from_montgomery arg5) + (twos_complement_eval arg3 mod 2) * eval (from_montgomery arg4)) mod m)
/// 0 ≤ eval out5 < m
/// 0 ≤ eval out5 < m
/// 0 ≤ eval out2 < m
/// 0 ≤ eval out3 < m
///
/// Input Bounds:
/// arg1: [0x0 ~> 0xffffffff]
/// arg2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]
/// arg3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]
/// arg4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]
/// arg5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]
/// Output Bounds:
/// out1: [0x0 ~> 0xffffffff]
/// out2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]
/// out3: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]
/// out4: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]
/// out5: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]
pub fn divstep(out1: *u32, out2: *[13]u32, out3: *[13]u32, out4: *[12]u32, out5: *[12]u32, arg1: u32, arg2: [13]u32, arg3: [13]u32, arg4: [12]u32, arg5: [12]u32) void {
@setRuntimeSafety(mode == .Debug);
var x1: u32 = undefined;
var x2: u1 = undefined;
addcarryxU32(&x1, &x2, 0x0, (~arg1), cast(u32, 0x1));
const x3 = (cast(u1, (x1 >> 31)) & cast(u1, ((arg3[0]) & cast(u32, 0x1))));
var x4: u32 = undefined;
var x5: u1 = undefined;
addcarryxU32(&x4, &x5, 0x0, (~arg1), cast(u32, 0x1));
var x6: u32 = undefined;
cmovznzU32(&x6, x3, arg1, x4);
var x7: u32 = undefined;
cmovznzU32(&x7, x3, (arg2[0]), (arg3[0]));
var x8: u32 = undefined;
cmovznzU32(&x8, x3, (arg2[1]), (arg3[1]));
var x9: u32 = undefined;
cmovznzU32(&x9, x3, (arg2[2]), (arg3[2]));
var x10: u32 = undefined;
cmovznzU32(&x10, x3, (arg2[3]), (arg3[3]));
var x11: u32 = undefined;
cmovznzU32(&x11, x3, (arg2[4]), (arg3[4]));
var x12: u32 = undefined;
cmovznzU32(&x12, x3, (arg2[5]), (arg3[5]));
var x13: u32 = undefined;
cmovznzU32(&x13, x3, (arg2[6]), (arg3[6]));
var x14: u32 = undefined;
cmovznzU32(&x14, x3, (arg2[7]), (arg3[7]));
var x15: u32 = undefined;
cmovznzU32(&x15, x3, (arg2[8]), (arg3[8]));
var x16: u32 = undefined;
cmovznzU32(&x16, x3, (arg2[9]), (arg3[9]));
var x17: u32 = undefined;
cmovznzU32(&x17, x3, (arg2[10]), (arg3[10]));
var x18: u32 = undefined;
cmovznzU32(&x18, x3, (arg2[11]), (arg3[11]));
var x19: u32 = undefined;
cmovznzU32(&x19, x3, (arg2[12]), (arg3[12]));
var x20: u32 = undefined;
var x21: u1 = undefined;
addcarryxU32(&x20, &x21, 0x0, cast(u32, 0x1), (~(arg2[0])));
var x22: u32 = undefined;
var x23: u1 = undefined;
addcarryxU32(&x22, &x23, x21, cast(u32, 0x0), (~(arg2[1])));
var x24: u32 = undefined;
var x25: u1 = undefined;
addcarryxU32(&x24, &x25, x23, cast(u32, 0x0), (~(arg2[2])));
var x26: u32 = undefined;
var x27: u1 = undefined;
addcarryxU32(&x26, &x27, x25, cast(u32, 0x0), (~(arg2[3])));
var x28: u32 = undefined;
var x29: u1 = undefined;
addcarryxU32(&x28, &x29, x27, cast(u32, 0x0), (~(arg2[4])));
var x30: u32 = undefined;
var x31: u1 = undefined;
addcarryxU32(&x30, &x31, x29, cast(u32, 0x0), (~(arg2[5])));
var x32: u32 = undefined;
var x33: u1 = undefined;
addcarryxU32(&x32, &x33, x31, cast(u32, 0x0), (~(arg2[6])));
var x34: u32 = undefined;
var x35: u1 = undefined;
addcarryxU32(&x34, &x35, x33, cast(u32, 0x0), (~(arg2[7])));
var x36: u32 = undefined;
var x37: u1 = undefined;
addcarryxU32(&x36, &x37, x35, cast(u32, 0x0), (~(arg2[8])));
var x38: u32 = undefined;
var x39: u1 = undefined;
addcarryxU32(&x38, &x39, x37, cast(u32, 0x0), (~(arg2[9])));
var x40: u32 = undefined;
var x41: u1 = undefined;
addcarryxU32(&x40, &x41, x39, cast(u32, 0x0), (~(arg2[10])));
var x42: u32 = undefined;
var x43: u1 = undefined;
addcarryxU32(&x42, &x43, x41, cast(u32, 0x0), (~(arg2[11])));
var x44: u32 = undefined;
var x45: u1 = undefined;
addcarryxU32(&x44, &x45, x43, cast(u32, 0x0), (~(arg2[12])));
var x46: u32 = undefined;
cmovznzU32(&x46, x3, (arg3[0]), x20);
var x47: u32 = undefined;
cmovznzU32(&x47, x3, (arg3[1]), x22);
var x48: u32 = undefined;
cmovznzU32(&x48, x3, (arg3[2]), x24);
var x49: u32 = undefined;
cmovznzU32(&x49, x3, (arg3[3]), x26);
var x50: u32 = undefined;
cmovznzU32(&x50, x3, (arg3[4]), x28);
var x51: u32 = undefined;
cmovznzU32(&x51, x3, (arg3[5]), x30);
var x52: u32 = undefined;
cmovznzU32(&x52, x3, (arg3[6]), x32);
var x53: u32 = undefined;
cmovznzU32(&x53, x3, (arg3[7]), x34);
var x54: u32 = undefined;
cmovznzU32(&x54, x3, (arg3[8]), x36);
var x55: u32 = undefined;
cmovznzU32(&x55, x3, (arg3[9]), x38);
var x56: u32 = undefined;
cmovznzU32(&x56, x3, (arg3[10]), x40);
var x57: u32 = undefined;
cmovznzU32(&x57, x3, (arg3[11]), x42);
var x58: u32 = undefined;
cmovznzU32(&x58, x3, (arg3[12]), x44);
var x59: u32 = undefined;
cmovznzU32(&x59, x3, (arg4[0]), (arg5[0]));
var x60: u32 = undefined;
cmovznzU32(&x60, x3, (arg4[1]), (arg5[1]));
var x61: u32 = undefined;
cmovznzU32(&x61, x3, (arg4[2]), (arg5[2]));
var x62: u32 = undefined;
cmovznzU32(&x62, x3, (arg4[3]), (arg5[3]));
var x63: u32 = undefined;
cmovznzU32(&x63, x3, (arg4[4]), (arg5[4]));
var x64: u32 = undefined;
cmovznzU32(&x64, x3, (arg4[5]), (arg5[5]));
var x65: u32 = undefined;
cmovznzU32(&x65, x3, (arg4[6]), (arg5[6]));
var x66: u32 = undefined;
cmovznzU32(&x66, x3, (arg4[7]), (arg5[7]));
var x67: u32 = undefined;
cmovznzU32(&x67, x3, (arg4[8]), (arg5[8]));
var x68: u32 = undefined;
cmovznzU32(&x68, x3, (arg4[9]), (arg5[9]));
var x69: u32 = undefined;
cmovznzU32(&x69, x3, (arg4[10]), (arg5[10]));
var x70: u32 = undefined;
cmovznzU32(&x70, x3, (arg4[11]), (arg5[11]));
var x71: u32 = undefined;
var x72: u1 = undefined;
addcarryxU32(&x71, &x72, 0x0, x59, x59);
var x73: u32 = undefined;
var x74: u1 = undefined;
addcarryxU32(&x73, &x74, x72, x60, x60);
var x75: u32 = undefined;
var x76: u1 = undefined;
addcarryxU32(&x75, &x76, x74, x61, x61);
var x77: u32 = undefined;
var x78: u1 = undefined;
addcarryxU32(&x77, &x78, x76, x62, x62);
var x79: u32 = undefined;
var x80: u1 = undefined;
addcarryxU32(&x79, &x80, x78, x63, x63);
var x81: u32 = undefined;
var x82: u1 = undefined;
addcarryxU32(&x81, &x82, x80, x64, x64);
var x83: u32 = undefined;
var x84: u1 = undefined;
addcarryxU32(&x83, &x84, x82, x65, x65);
var x85: u32 = undefined;
var x86: u1 = undefined;
addcarryxU32(&x85, &x86, x84, x66, x66);
var x87: u32 = undefined;
var x88: u1 = undefined;
addcarryxU32(&x87, &x88, x86, x67, x67);
var x89: u32 = undefined;
var x90: u1 = undefined;
addcarryxU32(&x89, &x90, x88, x68, x68);
var x91: u32 = undefined;
var x92: u1 = undefined;
addcarryxU32(&x91, &x92, x90, x69, x69);
var x93: u32 = undefined;
var x94: u1 = undefined;
addcarryxU32(&x93, &x94, x92, x70, x70);
var x95: u32 = undefined;
var x96: u1 = undefined;
subborrowxU32(&x95, &x96, 0x0, x71, 0xffffffff);
var x97: u32 = undefined;
var x98: u1 = undefined;
subborrowxU32(&x97, &x98, x96, x73, cast(u32, 0x0));
var x99: u32 = undefined;
var x100: u1 = undefined;
subborrowxU32(&x99, &x100, x98, x75, cast(u32, 0x0));
var x101: u32 = undefined;
var x102: u1 = undefined;
subborrowxU32(&x101, &x102, x100, x77, 0xffffffff);
var x103: u32 = undefined;
var x104: u1 = undefined;
subborrowxU32(&x103, &x104, x102, x79, 0xfffffffe);
var x105: u32 = undefined;
var x106: u1 = undefined;
subborrowxU32(&x105, &x106, x104, x81, 0xffffffff);
var x107: u32 = undefined;
var x108: u1 = undefined;
subborrowxU32(&x107, &x108, x106, x83, 0xffffffff);
var x109: u32 = undefined;
var x110: u1 = undefined;
subborrowxU32(&x109, &x110, x108, x85, 0xffffffff);
var x111: u32 = undefined;
var x112: u1 = undefined;
subborrowxU32(&x111, &x112, x110, x87, 0xffffffff);
var x113: u32 = undefined;
var x114: u1 = undefined;
subborrowxU32(&x113, &x114, x112, x89, 0xffffffff);
var x115: u32 = undefined;
var x116: u1 = undefined;
subborrowxU32(&x115, &x116, x114, x91, 0xffffffff);
var x117: u32 = undefined;
var x118: u1 = undefined;
subborrowxU32(&x117, &x118, x116, x93, 0xffffffff);
var x119: u32 = undefined;
var x120: u1 = undefined;
subborrowxU32(&x119, &x120, x118, cast(u32, x94), cast(u32, 0x0));
const x121 = (arg4[11]);
const x122 = (arg4[10]);
const x123 = (arg4[9]);
const x124 = (arg4[8]);
const x125 = (arg4[7]);
const x126 = (arg4[6]);
const x127 = (arg4[5]);
const x128 = (arg4[4]);
const x129 = (arg4[3]);
const x130 = (arg4[2]);
const x131 = (arg4[1]);
const x132 = (arg4[0]);
var x133: u32 = undefined;
var x134: u1 = undefined;
subborrowxU32(&x133, &x134, 0x0, cast(u32, 0x0), x132);
var x135: u32 = undefined;
var x136: u1 = undefined;
subborrowxU32(&x135, &x136, x134, cast(u32, 0x0), x131);
var x137: u32 = undefined;
var x138: u1 = undefined;
subborrowxU32(&x137, &x138, x136, cast(u32, 0x0), x130);
var x139: u32 = undefined;
var x140: u1 = undefined;
subborrowxU32(&x139, &x140, x138, cast(u32, 0x0), x129);
var x141: u32 = undefined;
var x142: u1 = undefined;
subborrowxU32(&x141, &x142, x140, cast(u32, 0x0), x128);
var x143: u32 = undefined;
var x144: u1 = undefined;
subborrowxU32(&x143, &x144, x142, cast(u32, 0x0), x127);
var x145: u32 = undefined;
var x146: u1 = undefined;
subborrowxU32(&x145, &x146, x144, cast(u32, 0x0), x126);
var x147: u32 = undefined;
var x148: u1 = undefined;
subborrowxU32(&x147, &x148, x146, cast(u32, 0x0), x125);
var x149: u32 = undefined;
var x150: u1 = undefined;
subborrowxU32(&x149, &x150, x148, cast(u32, 0x0), x124);
var x151: u32 = undefined;
var x152: u1 = undefined;
subborrowxU32(&x151, &x152, x150, cast(u32, 0x0), x123);
var x153: u32 = undefined;
var x154: u1 = undefined;
subborrowxU32(&x153, &x154, x152, cast(u32, 0x0), x122);
var x155: u32 = undefined;
var x156: u1 = undefined;
subborrowxU32(&x155, &x156, x154, cast(u32, 0x0), x121);
var x157: u32 = undefined;
cmovznzU32(&x157, x156, cast(u32, 0x0), 0xffffffff);
var x158: u32 = undefined;
var x159: u1 = undefined;
addcarryxU32(&x158, &x159, 0x0, x133, x157);
var x160: u32 = undefined;
var x161: u1 = undefined;
addcarryxU32(&x160, &x161, x159, x135, cast(u32, 0x0));
var x162: u32 = undefined;
var x163: u1 = undefined;
addcarryxU32(&x162, &x163, x161, x137, cast(u32, 0x0));
var x164: u32 = undefined;
var x165: u1 = undefined;
addcarryxU32(&x164, &x165, x163, x139, x157);
var x166: u32 = undefined;
var x167: u1 = undefined;
addcarryxU32(&x166, &x167, x165, x141, (x157 & 0xfffffffe));
var x168: u32 = undefined;
var x169: u1 = undefined;
addcarryxU32(&x168, &x169, x167, x143, x157);
var x170: u32 = undefined;
var x171: u1 = undefined;
addcarryxU32(&x170, &x171, x169, x145, x157);
var x172: u32 = undefined;
var x173: u1 = undefined;
addcarryxU32(&x172, &x173, x171, x147, x157);
var x174: u32 = undefined;
var x175: u1 = undefined;
addcarryxU32(&x174, &x175, x173, x149, x157);
var x176: u32 = undefined;
var x177: u1 = undefined;
addcarryxU32(&x176, &x177, x175, x151, x157);
var x178: u32 = undefined;
var x179: u1 = undefined;
addcarryxU32(&x178, &x179, x177, x153, x157);
var x180: u32 = undefined;
var x181: u1 = undefined;
addcarryxU32(&x180, &x181, x179, x155, x157);
var x182: u32 = undefined;
cmovznzU32(&x182, x3, (arg5[0]), x158);
var x183: u32 = undefined;
cmovznzU32(&x183, x3, (arg5[1]), x160);
var x184: u32 = undefined;
cmovznzU32(&x184, x3, (arg5[2]), x162);
var x185: u32 = undefined;
cmovznzU32(&x185, x3, (arg5[3]), x164);
var x186: u32 = undefined;
cmovznzU32(&x186, x3, (arg5[4]), x166);
var x187: u32 = undefined;
cmovznzU32(&x187, x3, (arg5[5]), x168);
var x188: u32 = undefined;
cmovznzU32(&x188, x3, (arg5[6]), x170);
var x189: u32 = undefined;
cmovznzU32(&x189, x3, (arg5[7]), x172);
var x190: u32 = undefined;
cmovznzU32(&x190, x3, (arg5[8]), x174);
var x191: u32 = undefined;
cmovznzU32(&x191, x3, (arg5[9]), x176);
var x192: u32 = undefined;
cmovznzU32(&x192, x3, (arg5[10]), x178);
var x193: u32 = undefined;
cmovznzU32(&x193, x3, (arg5[11]), x180);
const x194 = cast(u1, (x46 & cast(u32, 0x1)));
var x195: u32 = undefined;
cmovznzU32(&x195, x194, cast(u32, 0x0), x7);
var x196: u32 = undefined;
cmovznzU32(&x196, x194, cast(u32, 0x0), x8);
var x197: u32 = undefined;
cmovznzU32(&x197, x194, cast(u32, 0x0), x9);
var x198: u32 = undefined;
cmovznzU32(&x198, x194, cast(u32, 0x0), x10);
var x199: u32 = undefined;
cmovznzU32(&x199, x194, cast(u32, 0x0), x11);
var x200: u32 = undefined;
cmovznzU32(&x200, x194, cast(u32, 0x0), x12);
var x201: u32 = undefined;
cmovznzU32(&x201, x194, cast(u32, 0x0), x13);
var x202: u32 = undefined;
cmovznzU32(&x202, x194, cast(u32, 0x0), x14);
var x203: u32 = undefined;
cmovznzU32(&x203, x194, cast(u32, 0x0), x15);
var x204: u32 = undefined;
cmovznzU32(&x204, x194, cast(u32, 0x0), x16);
var x205: u32 = undefined;
cmovznzU32(&x205, x194, cast(u32, 0x0), x17);
var x206: u32 = undefined;
cmovznzU32(&x206, x194, cast(u32, 0x0), x18);
var x207: u32 = undefined;
cmovznzU32(&x207, x194, cast(u32, 0x0), x19);
var x208: u32 = undefined;
var x209: u1 = undefined;
addcarryxU32(&x208, &x209, 0x0, x46, x195);
var x210: u32 = undefined;
var x211: u1 = undefined;
addcarryxU32(&x210, &x211, x209, x47, x196);
var x212: u32 = undefined;
var x213: u1 = undefined;
addcarryxU32(&x212, &x213, x211, x48, x197);
var x214: u32 = undefined;
var x215: u1 = undefined;
addcarryxU32(&x214, &x215, x213, x49, x198);
var x216: u32 = undefined;
var x217: u1 = undefined;
addcarryxU32(&x216, &x217, x215, x50, x199);
var x218: u32 = undefined;
var x219: u1 = undefined;
addcarryxU32(&x218, &x219, x217, x51, x200);
var x220: u32 = undefined;
var x221: u1 = undefined;
addcarryxU32(&x220, &x221, x219, x52, x201);
var x222: u32 = undefined;
var x223: u1 = undefined;
addcarryxU32(&x222, &x223, x221, x53, x202);
var x224: u32 = undefined;
var x225: u1 = undefined;
addcarryxU32(&x224, &x225, x223, x54, x203);
var x226: u32 = undefined;
var x227: u1 = undefined;
addcarryxU32(&x226, &x227, x225, x55, x204);
var x228: u32 = undefined;
var x229: u1 = undefined;
addcarryxU32(&x228, &x229, x227, x56, x205);
var x230: u32 = undefined;
var x231: u1 = undefined;
addcarryxU32(&x230, &x231, x229, x57, x206);
var x232: u32 = undefined;
var x233: u1 = undefined;
addcarryxU32(&x232, &x233, x231, x58, x207);
var x234: u32 = undefined;
cmovznzU32(&x234, x194, cast(u32, 0x0), x59);
var x235: u32 = undefined;
cmovznzU32(&x235, x194, cast(u32, 0x0), x60);
var x236: u32 = undefined;
cmovznzU32(&x236, x194, cast(u32, 0x0), x61);
var x237: u32 = undefined;
cmovznzU32(&x237, x194, cast(u32, 0x0), x62);
var x238: u32 = undefined;
cmovznzU32(&x238, x194, cast(u32, 0x0), x63);
var x239: u32 = undefined;
cmovznzU32(&x239, x194, cast(u32, 0x0), x64);
var x240: u32 = undefined;
cmovznzU32(&x240, x194, cast(u32, 0x0), x65);
var x241: u32 = undefined;
cmovznzU32(&x241, x194, cast(u32, 0x0), x66);
var x242: u32 = undefined;
cmovznzU32(&x242, x194, cast(u32, 0x0), x67);
var x243: u32 = undefined;
cmovznzU32(&x243, x194, cast(u32, 0x0), x68);
var x244: u32 = undefined;
cmovznzU32(&x244, x194, cast(u32, 0x0), x69);
var x245: u32 = undefined;
cmovznzU32(&x245, x194, cast(u32, 0x0), x70);
var x246: u32 = undefined;
var x247: u1 = undefined;
addcarryxU32(&x246, &x247, 0x0, x182, x234);
var x248: u32 = undefined;
var x249: u1 = undefined;
addcarryxU32(&x248, &x249, x247, x183, x235);
var x250: u32 = undefined;
var x251: u1 = undefined;
addcarryxU32(&x250, &x251, x249, x184, x236);
var x252: u32 = undefined;
var x253: u1 = undefined;
addcarryxU32(&x252, &x253, x251, x185, x237);
var x254: u32 = undefined;
var x255: u1 = undefined;
addcarryxU32(&x254, &x255, x253, x186, x238);
var x256: u32 = undefined;
var x257: u1 = undefined;
addcarryxU32(&x256, &x257, x255, x187, x239);
var x258: u32 = undefined;
var x259: u1 = undefined;
addcarryxU32(&x258, &x259, x257, x188, x240);
var x260: u32 = undefined;
var x261: u1 = undefined;
addcarryxU32(&x260, &x261, x259, x189, x241);
var x262: u32 = undefined;
var x263: u1 = undefined;
addcarryxU32(&x262, &x263, x261, x190, x242);
var x264: u32 = undefined;
var x265: u1 = undefined;
addcarryxU32(&x264, &x265, x263, x191, x243);
var x266: u32 = undefined;
var x267: u1 = undefined;
addcarryxU32(&x266, &x267, x265, x192, x244);
var x268: u32 = undefined;
var x269: u1 = undefined;
addcarryxU32(&x268, &x269, x267, x193, x245);
var x270: u32 = undefined;
var x271: u1 = undefined;
subborrowxU32(&x270, &x271, 0x0, x246, 0xffffffff);
var x272: u32 = undefined;
var x273: u1 = undefined;
subborrowxU32(&x272, &x273, x271, x248, cast(u32, 0x0));
var x274: u32 = undefined;
var x275: u1 = undefined;
subborrowxU32(&x274, &x275, x273, x250, cast(u32, 0x0));
var x276: u32 = undefined;
var x277: u1 = undefined;
subborrowxU32(&x276, &x277, x275, x252, 0xffffffff);
var x278: u32 = undefined;
var x279: u1 = undefined;
subborrowxU32(&x278, &x279, x277, x254, 0xfffffffe);
var x280: u32 = undefined;
var x281: u1 = undefined;
subborrowxU32(&x280, &x281, x279, x256, 0xffffffff);
var x282: u32 = undefined;
var x283: u1 = undefined;
subborrowxU32(&x282, &x283, x281, x258, 0xffffffff);
var x284: u32 = undefined;
var x285: u1 = undefined;
subborrowxU32(&x284, &x285, x283, x260, 0xffffffff);
var x286: u32 = undefined;
var x287: u1 = undefined;
subborrowxU32(&x286, &x287, x285, x262, 0xffffffff);
var x288: u32 = undefined;
var x289: u1 = undefined;
subborrowxU32(&x288, &x289, x287, x264, 0xffffffff);
var x290: u32 = undefined;
var x291: u1 = undefined;
subborrowxU32(&x290, &x291, x289, x266, 0xffffffff);
var x292: u32 = undefined;
var x293: u1 = undefined;
subborrowxU32(&x292, &x293, x291, x268, 0xffffffff);
var x294: u32 = undefined;
var x295: u1 = undefined;
subborrowxU32(&x294, &x295, x293, cast(u32, x269), cast(u32, 0x0));
var x296: u32 = undefined;
var x297: u1 = undefined;
addcarryxU32(&x296, &x297, 0x0, x6, cast(u32, 0x1));
const x298 = ((x208 >> 1) | ((x210 << 31) & 0xffffffff));
const x299 = ((x210 >> 1) | ((x212 << 31) & 0xffffffff));
const x300 = ((x212 >> 1) | ((x214 << 31) & 0xffffffff));
const x301 = ((x214 >> 1) | ((x216 << 31) & 0xffffffff));
const x302 = ((x216 >> 1) | ((x218 << 31) & 0xffffffff));
const x303 = ((x218 >> 1) | ((x220 << 31) & 0xffffffff));
const x304 = ((x220 >> 1) | ((x222 << 31) & 0xffffffff));
const x305 = ((x222 >> 1) | ((x224 << 31) & 0xffffffff));
const x306 = ((x224 >> 1) | ((x226 << 31) & 0xffffffff));
const x307 = ((x226 >> 1) | ((x228 << 31) & 0xffffffff));
const x308 = ((x228 >> 1) | ((x230 << 31) & 0xffffffff));
const x309 = ((x230 >> 1) | ((x232 << 31) & 0xffffffff));
const x310 = ((x232 & 0x80000000) | (x232 >> 1));
var x311: u32 = undefined;
cmovznzU32(&x311, x120, x95, x71);
var x312: u32 = undefined;
cmovznzU32(&x312, x120, x97, x73);
var x313: u32 = undefined;
cmovznzU32(&x313, x120, x99, x75);
var x314: u32 = undefined;
cmovznzU32(&x314, x120, x101, x77);
var x315: u32 = undefined;
cmovznzU32(&x315, x120, x103, x79);
var x316: u32 = undefined;
cmovznzU32(&x316, x120, x105, x81);
var x317: u32 = undefined;
cmovznzU32(&x317, x120, x107, x83);
var x318: u32 = undefined;
cmovznzU32(&x318, x120, x109, x85);
var x319: u32 = undefined;
cmovznzU32(&x319, x120, x111, x87);
var x320: u32 = undefined;
cmovznzU32(&x320, x120, x113, x89);
var x321: u32 = undefined;
cmovznzU32(&x321, x120, x115, x91);
var x322: u32 = undefined;
cmovznzU32(&x322, x120, x117, x93);
var x323: u32 = undefined;
cmovznzU32(&x323, x295, x270, x246);
var x324: u32 = undefined;
cmovznzU32(&x324, x295, x272, x248);
var x325: u32 = undefined;
cmovznzU32(&x325, x295, x274, x250);
var x326: u32 = undefined;
cmovznzU32(&x326, x295, x276, x252);
var x327: u32 = undefined;
cmovznzU32(&x327, x295, x278, x254);
var x328: u32 = undefined;
cmovznzU32(&x328, x295, x280, x256);
var x329: u32 = undefined;
cmovznzU32(&x329, x295, x282, x258);
var x330: u32 = undefined;
cmovznzU32(&x330, x295, x284, x260);
var x331: u32 = undefined;
cmovznzU32(&x331, x295, x286, x262);
var x332: u32 = undefined;
cmovznzU32(&x332, x295, x288, x264);
var x333: u32 = undefined;
cmovznzU32(&x333, x295, x290, x266);
var x334: u32 = undefined;
cmovznzU32(&x334, x295, x292, x268);
out1.* = x296;
out2[0] = x7;
out2[1] = x8;
out2[2] = x9;
out2[3] = x10;
out2[4] = x11;
out2[5] = x12;
out2[6] = x13;
out2[7] = x14;
out2[8] = x15;
out2[9] = x16;
out2[10] = x17;
out2[11] = x18;
out2[12] = x19;
out3[0] = x298;
out3[1] = x299;
out3[2] = x300;
out3[3] = x301;
out3[4] = x302;
out3[5] = x303;
out3[6] = x304;
out3[7] = x305;
out3[8] = x306;
out3[9] = x307;
out3[10] = x308;
out3[11] = x309;
out3[12] = x310;
out4[0] = x311;
out4[1] = x312;
out4[2] = x313;
out4[3] = x314;
out4[4] = x315;
out4[5] = x316;
out4[6] = x317;
out4[7] = x318;
out4[8] = x319;
out4[9] = x320;
out4[10] = x321;
out4[11] = x322;
out5[0] = x323;
out5[1] = x324;
out5[2] = x325;
out5[3] = x326;
out5[4] = x327;
out5[5] = x328;
out5[6] = x329;
out5[7] = x330;
out5[8] = x331;
out5[9] = x332;
out5[10] = x333;
out5[11] = x334;
}
/// The function divstepPrecomp returns the precomputed value for Bernstein-Yang-inversion (in montgomery form).
///
/// Postconditions:
/// eval (from_montgomery out1) = ⌊(m - 1) / 2⌋^(if ⌊log2 m⌋ + 1 < 46 then ⌊(49 * (⌊log2 m⌋ + 1) + 80) / 17⌋ else ⌊(49 * (⌊log2 m⌋ + 1) + 57) / 17⌋)
/// 0 ≤ eval out1 < m
///
/// Output Bounds:
/// out1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]
pub fn divstepPrecomp(out1: *[12]u32) void {
@setRuntimeSafety(mode == .Debug);
out1[0] = 0xfff18fff;
out1[1] = 0xfff69400;
out1[2] = 0xffffd3ff;
out1[3] = 0x2b7fe;
out1[4] = 0xfffe97ff;
out1[5] = 0xfffedbff;
out1[6] = 0x2fff;
out1[7] = 0x28400;
out1[8] = 0x50400;
out1[9] = 0x60400;
out1[10] = 0x38000;
out1[11] = 0xfffc4800;
}
| 37.705037 | 831 | 0.613481 |
4653d8668ebbaa068c9689af438a37f0e06a0b83 | 166 | zig | Zig | test/compile_errors/stage1/obj/indexing_a_undefined_slice_at_comptime.zig | damienfir/zig | 1a1b5ee264d8b2219c34d53cc9602692e6d2ba24 | [
"MIT"
] | null | null | null | test/compile_errors/stage1/obj/indexing_a_undefined_slice_at_comptime.zig | damienfir/zig | 1a1b5ee264d8b2219c34d53cc9602692e6d2ba24 | [
"MIT"
] | null | null | null | test/compile_errors/stage1/obj/indexing_a_undefined_slice_at_comptime.zig | damienfir/zig | 1a1b5ee264d8b2219c34d53cc9602692e6d2ba24 | [
"MIT"
] | null | null | null | comptime {
var slice: []u8 = undefined;
slice[0] = 2;
}
// indexing a undefined slice at comptime
//
// tmp.zig:3:10: error: index 0 outside slice of size 0
| 18.444444 | 55 | 0.638554 |
4ce93e6b519fe0f52971bb42b3bb44b8908daa9c | 176 | zig | Zig | test/cases/compile_errors/stage1/obj/write_to_const_global_variable.zig | mparadinha/zig | e498fb155051f548071da1a13098b8793f527275 | [
"MIT"
] | 730 | 2017-04-25T06:34:15.000Z | 2018-05-23T16:11:36.000Z | test/cases/compile_errors/stage1/obj/write_to_const_global_variable.zig | mparadinha/zig | e498fb155051f548071da1a13098b8793f527275 | [
"MIT"
] | 691 | 2017-04-25T04:33:29.000Z | 2018-05-23T05:31:49.000Z | test/cases/compile_errors/stage1/obj/write_to_const_global_variable.zig | mparadinha/zig | e498fb155051f548071da1a13098b8793f527275 | [
"MIT"
] | 72 | 2017-04-30T14:31:55.000Z | 2018-05-16T22:15:31.000Z | const x : i32 = 99;
fn f() void {
x = 1;
}
export fn entry() void { f(); }
// error
// backend=stage1
// target=native
//
// tmp.zig:3:9: error: cannot assign to constant
| 14.666667 | 48 | 0.585227 |
fb919bc204407b89394dbbbfc64baf3458e783fb | 2,729 | zig | Zig | src/math/rect.zig | foxnne/zig-upaya | 50e27c2d8d0f07c6699fb0c727fc446dff3daf43 | [
"MIT"
] | 1 | 2021-07-13T20:58:49.000Z | 2021-07-13T20:58:49.000Z | src/math/rect.zig | foxnne/zig-upaya | 50e27c2d8d0f07c6699fb0c727fc446dff3daf43 | [
"MIT"
] | null | null | null | src/math/rect.zig | foxnne/zig-upaya | 50e27c2d8d0f07c6699fb0c727fc446dff3daf43 | [
"MIT"
] | 1 | 2021-07-17T19:03:53.000Z | 2021-07-17T19:03:53.000Z | const std = @import("std");
const Edge = enum{
left,
right,
top,
bottom
};
pub const RectF = struct {
x: f32 = 0,
y: f32 = 0,
width: f32 = 0,
height: f32 = 0,
};
pub const Rect = struct {
x: i32 = 0,
y: i32 = 0,
width: i32 = 0,
height: i32 = 0,
pub fn right(self: Rect) i32 {
return self.x + self.width;
}
pub fn left(self: Rect) i32 {
return self.x;
}
pub fn top(self: Rect) i32 {
return self.y;
}
pub fn bottom(self: Rect) i32 {
return self.y + self.height;
}
pub fn centerX(self: Rect) i32 {
return self.x + @divTrunc(self.width, 2);
}
pub fn centerY(self: Rect) i32 {
return self.y + @divTrunc(self.height, 2);
}
pub fn halfRect(self: Rect, edge: Edge) Rect {
return switch (edge) {
.top => Rect{ .x = self.x, .y = self.y, .width = self.width, .h = @divTrunc(self.height, 2) },
.bottom => Rect{ .x = self.x, .y = self.y + @divTrunc(self.h, 2), .width = self.width, .height = @divTrunc(self.height, 2) },
.left => Rect{ .x = self.x, .y = self.y, .width = @divTrunc(self.width, 2), .h = self.height },
.right => Rect{ .x = self.x + @divTrunc(self.width, 2), .y = self.y, .width = @divTrunc(self.width, 2), .height = self.height },
};
}
pub fn contract(self: *Rect, hor: i32, vert: i32) void {
self.x += hor;
self.y += vert;
self.width -= hor * 2;
self.height -= vert * 2;
}
pub fn expandEdge(self: *Rect, edge: Edge, move_x: i32) void {
const amt = std.math.absInt(move_x) catch unreachable;
switch (edge) {
.top => {
self.y -= amt;
self.height += amt;
},
.bottom => {
self.height += amt;
},
.left => {
self.x -= amt;
self.width += amt;
},
.right => {
self.width += amt;
},
}
}
pub fn side(self: Rect, edge: Edge) i32 {
return switch (edge) {
.left => self.x,
.right => self.x + self.width,
.top => self.y,
.bottom => self.y + self.height,
};
}
pub fn contains(self: Rect, x: i32, y: i32) bool {
return self.x <= x and x < self.right() and self.y <= y and y < self.bottom();
}
pub fn asRectF(self: Rect) RectF {
return .{
.x = @intToFloat(f32, self.x),
.y = @intToFloat(f32, self.y),
.width = @intToFloat(f32, self.width),
.height = @intToFloat(f32, self.height),
};
}
};
| 25.990476 | 140 | 0.466471 |
e875738e65be201f9b18039768cb115b7c02519c | 42,003 | zig | Zig | src/markdown/markdown.zig | gernest/hoodie | 234e80572428f10adce35080e4679ad8b295d0cb | [
"MIT"
] | 19 | 2019-09-06T21:26:52.000Z | 2021-02-13T23:18:37.000Z | src/markdown/markdown.zig | gernest/hoodie | 234e80572428f10adce35080e4679ad8b295d0cb | [
"MIT"
] | null | null | null | src/markdown/markdown.zig | gernest/hoodie | 234e80572428f10adce35080e4679ad8b295d0cb | [
"MIT"
] | 1 | 2020-09-13T23:54:12.000Z | 2020-09-13T23:54:12.000Z | const std = @import("std");
const ascii = std.ascii;
const mem = std.mem;
const io = std.io;
const Buffer = std.Buffer;
pub const EXTENSION_NO_INTRA_EMPHASIS = 1;
pub const EXTENSION_TABLES = 2;
pub const EXTENSION_FENCED_CODE = 4;
pub const EXTENSION_AUTOLINK = 8;
pub const EXTENSION_STRIKETHROUGH = 16;
pub const EXTENSION_LAX_HTML_BLOCKS = 32;
pub const EXTENSION_SPACE_HEADERS = 64;
pub const EXTENSION_HARD_LINE_BREAK = 128;
pub const EXTENSION_TAB_SIZE_EIGHT = 256;
pub const EXTENSION_FOOTNOTES = 512;
pub const EXTENSION_NO_EMPTY_LINE_BEFORE_BLOCK = 1024;
pub const EXTENSION_HEADER_IDS = 2048;
pub const EXTENSION_TITLEBLOCK = 4096;
pub const EXTENSION_AUTO_HEADER_IDS = 8192;
pub const EXTENSION_BACKSLASH_LINE_BREAK = 16384;
pub const EXTENSION_DEFINITION_LISTS = 32768;
pub const EXTENSION_JOIN_LINES = 65536;
const common_extensions = 0 |
EXTENSION_NO_INTRA_EMPHASIS |
EXTENSION_TABLES |
EXTENSION_FENCED_CODE |
EXTENSION_AUTOLINK |
EXTENSION_STRIKETHROUGH |
EXTENSION_SPACE_HEADERS |
EXTENSION_HEADER_IDS |
EXTENSION_BACKSLASH_LINE_BREAK |
EXTENSION_DEFINITION_LISTS;
pub const LINK_TYPE_NOT_AUTOLINK = 1;
pub const LINK_TYPE_NORMAL = 2;
pub const LINK_TYPE_EMAIL = 4;
pub const LIST_TYPE_ORDERED = 1;
pub const LIST_TYPE_DEFINITION = 2;
pub const LIST_TYPE_TERM = 4;
pub const LIST_ITEM_CONTAINS_BLOCK = 8;
pub const LIST_ITEM_BEGINNING_OF_LIST = 16;
pub const LIST_ITEM_END_OF_LIST = 32;
pub const TABLE_ALIGNMENT_LEFT = 1;
pub const TABLE_ALIGNMENT_RIGHT = 2;
pub const TABLE_ALIGNMENT_CENTER = 3;
pub const TAB_SIZE_DEFAULT = 4;
pub const TAB_SIZE_EIGHT = 8;
pub const TextIter = struct {
nextFn: fn (x: *TextIter) bool,
pub fn text(self: *TextIter) bool {
return self.nextFn(self);
}
};
pub const Renderer = struct {
//block-level
blockCodeFn: fn (r: *Renderer, out: *Buffer, text: []const u8, info_string: []const u8) anyerror!void,
blockQuoteFn: fn (r: *Renderer, out: *Buffer, text: []const u8) anyerror!void,
blockHtmlFn: fn (r: *Renderer, out: *Buffer, text: []const u8) anyerror!void,
headerFn: fn (r: *Renderer, out: *Buffer, text: *TextIter, level: usize, id: ?[]const u8) anyerror!void,
hruleFn: fn (r: *Renderer, out: *Buffer) anyerror!void,
listFn: fn (r: *Renderer, out: *Buffer, text: *TextIter, flags: usize) anyerror!void,
listItemFn: fn (r: *Renderer, out: *Buffer, text: []const u8, flags: usize) anyerror!void,
paragraphFn: fn (r: *Renderer, out: *Buffer, text: *TextIter) anyerror!void,
tableFn: fn (r: *Renderer, out: *Buffer, header: []const u8, body: []const u8, colum_data: []usize) anyerror!void,
tableRowFn: fn (r: *Renderer, out: *Buffer, text: []const u8) anyerror!void,
tableHeaderCellFn: fn (r: *Renderer, out: *Buffer, text: []const u8, flags: usize) anyerror!void,
tableCellFn: fn (r: *Renderer, out: *Buffer, text: []const u8, flags: usize) anyerror!void,
footnotesFn: fn (r: *Renderer, out: *Buffer, text: *TextIter) anyerror!void,
footnoteItemFn: fn (r: *Renderer, out: *Buffer, name: []const u8, text: []const u8, flags: usize) anyerror!void,
titleBlockFn: fn (r: *Renderer, out: *Buffer, text: []const u8) anyerror!void,
// Span-level callbacks
autoLinkFn: fn (r: *Renderer, buf: *Buffer, link: []const u8, kind: usize) anyerror!void,
codeSpanFn: fn (r: *Renderer, buf: *Buffer, text: []const u8) anyerror!void,
doubleEmphasisFn: fn (r: *Renderer, buf: *Buffer, text: []const u8) anyerror!void,
emphasisFn: fn (r: *Renderer, buf: *Buffer, text: []const u8) anyerror!void,
imageFn: fn (r: *Renderer, buf: *Buffer, link: []const u8, title: ?[]const u8, alt: ?[]const u8) anyerror!void,
lineBreakFn: fn (r: *Renderer, buf: *Buffer) anyerror!void,
linkFn: fn (r: *Renderer, buf: *Buffer, link: []const u8, title: ?[]const u8, content: []const u8) anyerror!void,
rawHtmlTagFn: fn (r: *Renderer, buf: *Buffer, tag: []const u8) anyerror!void,
tripleEmphasisFn: fn (r: *Renderer, buf: *Buffer, text: []const u8) anyerror!void,
strikeThroughFn: fn (r: *Renderer, buf: *Buffer, text: []const u8) anyerror!void,
footnoteRefFn: fn (r: *Renderer, buf: *Buffer, ref: []const u8, id: usize) anyerror!void,
// Low-level callbacks
entityFn: fn (r: *Renderer, buf: *Buffer, entity: []const u8) anyerror!void,
normalTextFn: fn (r: *Renderer, buf: *Buffer, text: []const u8) anyerror!void,
// Header and footer
documentHeaderFn: fn (r: *Renderer, buf: *Buffer) anyerror!void,
documentFooterFn: fn (r: *Renderer, buf: *Buffer) anyerror!void,
getFlagsFn: fn (r: *Renderer) usize,
pub fn blockCode(self: *Renderer, out: *Buffer, text: []const u8, info_string: []const u8) anyerror!void {
try self.blockCodeFn(self, out, text, info_string);
}
pub fn blockQuote(self: *Renderer, out: *Buffer, text: []const u8) anyerror!void {
try self.blockQuoteFn(self, out, text);
}
pub fn blockHtml(self: *Renderer, out: *Buffer, text: []const u8) anyerror!void {
try self.blockHtmlFn(self, out, text);
}
pub fn header(self: *Renderer, out: *Buffer, text: *TextIter, level: usize, id: []const u8) anyerror!void {
try self.headerFn(self, out, text, level, id);
}
pub fn hrule(self: *Renderer, out: *Buffer) anyerror!void {
try self.hruleFn(self, out);
}
pub fn list(self: *Renderer, out: *Buffer, text: *TextIter, flags: usize) anyerror!void {
try self.listFn(self, out, text, flags);
}
pub fn listItem(self: *Renderer, out: *Buffer, text: []const u8, flags: usize) anyerror!void {
try self.listItemFn(self, out, text, flags);
}
pub fn paragraph(self: *Renderer, out: *Buffer, text: *TextIter) anyerror!void {
try self.paragraphFn(self, out, text);
}
pub fn table(self: *Renderer, out: *Buffer, header: []const u8, body: []const u8, colum_data: []usize) anyerror!void {
try self.tableFn(self, out, header, body, colum_data);
}
pub fn tableRow(self: *Renderer, out: *Buffer, text: []const u8) anyerror!void {
try self.tableRowFn(self, out, text);
}
pub fn tableHeaderCell(self: *Renderer, out: *Buffer, text: []const u8, flags: usize) anyerror!void {
try self.tableHeaderCellFn(self, out, text, flags);
}
pub fn tableCell(self: *Renderer, out: *Buffer, text: []const u8, flags: usize) anyerror!void {
try self.tableCellFn(self, out, text, flags);
}
pub fn footnotes(self: *Renderer, out: *Buffer, text: *TextIter) anyerror!void {
try self.footnotesFn(self, out, text);
}
pub fn footnoteItem(self: *Renderer, out: *Buffer, name: []const u8, text: []const u8, flags: usize) anyerror!void {
try self.footnoteItemFn(self, out, name, text, flags);
}
pub fn titleBlock(self: *Renderer, out: *Buffer, text: []const u8) anyerror!void {
try self.titleBlockFn(self, out, text);
}
pub fn autoLink(self: *Renderer, buf: *Buffer, link: []const u8, kind: usize) anyerror!void {
try self.autoLinkFn(self, buf, link, kind);
}
pub fn codeSpan(self: *Renderer, buf: *Buffer, text: []const u8) anyerror!void {
try self.codeSpanFn(self, buf, text);
}
pub fn doubleEmphasis(self: *Renderer, buf: *Buffer, text: []const u8) anyerror!void {
try self.doubleEmphasisFn(self, buf, text);
}
pub fn emphasis(self: *Renderer, buf: *Buffer, text: []const u8) anyerror!void {
try self.emphasisFn(self, buf, text);
}
pub fn image(self: *Renderer, buf: *Buffer, link: []const u8, title: []const u8, alt: []const u8) anyerror!void {
try self.imageFn(self, buf, link, title, alt);
}
pub fn lineBreak(self: *Renderer, buf: *Buffer) anyerror!void {
try self.lineBreakFn(self, buf);
}
pub fn link(self: *Renderer, buf: *Buffer, link: []const u8, title: ?[]const u8, content: []const u8) anyerror!void {
try self.linkFn(self, buf, link, title, content);
}
pub fn rawHtmlTag(self: *Renderer, buf: *Buffer, tag: []const u8) anyerror!void {
try self.rawHtmlTagFn(self, buf, tag);
}
pub fn tripleEmphasis(self: *Renderer, buf: *Buffer, text: []const u8) anyerror!void {
try self.tripleEmphasisFn(self, buf, text);
}
pub fn strikeThrough(self: *Renderer, buf: *Buffer, text: []const u8) anyerror!void {
try self.strikeThroughFn(self, buf, text);
}
pub fn footnoteRef(self: *Renderer, buf: *Buffer, ref: []const u8, id: usize) anyerror!void {
try self.footnoteRefFn(self, buf, id);
}
pub fn entity(self: *Renderer, buf: *Buffer, entity: []const u8) anyerror!void {
try self.entityFn(self, buf, entity);
}
pub fn normalText(self: *Renderer, buf: *Buffer, text: []const u8) anyerror!void {
try self.normalTextFn(self, buf, text);
}
pub fn documentHeader(self: *Renderer, buf: *Buffer) anyerror!void {
try self.documentHeaderFn(self, buf);
}
pub fn documentFooter(self: *Renderer, buf: *Buffer) anyerror!void {
try self.documentFooterFn(self, buf);
}
pub fn getFlags(self: *Renderer) usize {
try self.getFlagsFn(self);
}
};
pub const HTML_SKIP_HTML = 1;
pub const HTML_SKIP_STYLE = 2;
pub const HTML_SKIP_IMAGES = 4;
pub const HTML_SKIP_LINKS = 8;
pub const HTML_SAFELINK = 16;
pub const HTML_NOFOLLOW_LINKS = 32;
pub const HTML_NOREFERRER_LINKS = 64;
pub const HTML_HREF_TARGET_BLANK = 128;
pub const HTML_TOC = 256;
pub const HTML_OMIT_CONTENTS = 512;
pub const HTML_COMPLETE_PAGE = 1024;
pub const HTML_USE_XHTML = 2048;
pub const HTML_USE_SMARTYPANTS = 4096;
pub const HTML_SMARTYPANTS_FRACTIONS = 8192;
pub const HTML_SMARTYPANTS_DASHES = 16384;
pub const HTML_SMARTYPANTS_LATEX_DASHES = 32768;
pub const HTML_SMARTYPANTS_ANGLED_QUOTES = 65536;
pub const HTML_SMARTYPANTS_QUOTES_NBSP = 131072;
pub const HTML_FOOTNOTE_RETURN_LINKS = 262144;
const common_html_flags = 0 |
HTML_USE_XHTML |
HTML_USE_SMARTYPANTS |
HTML_SMARTYPANTS_FRACTIONS |
HTML_SMARTYPANTS_DASHES |
HTML_SMARTYPANTS_LATEX_DASHES;
pub const ID = struct {
txt: ?[]const u8,
prefix: ?[]const u8,
suffix: ?[]const u8,
index: i64,
toc: bool,
pub fn init(
txt: ?[]const u8,
prefix: ?[]const u8,
suffix: ?[]const u8,
index: i64,
toc: bool,
) ID {
return ID{
.txt = txt,
.prefix = prefix,
.suffix = suffix,
.index = index,
.toc = toc,
};
}
pub fn valid(self: ID) bool {
if (self.txt != null or self.toc) return true;
return false;
}
pub fn format(
self: ID,
comptime fmt: []const u8,
comptime options: std.fmt.FormatOptions,
context: var,
comptime Errors: type,
output: fn (@typeOf(context), []const u8) Errors!void,
) Errors!void {
if (self.prefix) |prefix| {
try output(context, prefix);
}
if (self.txt) |txt| {
try output(context, txt);
} else if (self.toc) {
try output(context, "toc");
}
try std.fmt.format(
context,
Errors,
output,
"_{}",
self.index,
);
if (self.suffix) |suffix| {
try output(context, suffix);
}
}
};
pub const HTML = struct {
flags: usize,
close_tag: []const u8,
title: ?[]const u8,
css: ?[]const u8,
params: Params,
toc_marker: usize,
header_count: i64,
current_level: usize,
toc: Buffer,
renderer: Renderer,
pub const Params = struct {
absolute_prefix: ?[]const u8,
footnote_anchor_prefix: ?[]const u8,
footnote_return_link_contents: ?[]const u8,
header_id_prefix: ?[]const u8,
header_id_suffix: ?[]const u8,
};
const xhtml_close = "/>";
const html_close = ">";
pub fn init(a: *mem.Allocator) !HTML {
return HTML{
.flags = common_html_flags,
.close_tag = html_close,
.title = null,
.css = null,
.params = Params{
.absolute_prefix = null,
.footnote_anchor_prefix = null,
.footnote_return_link_contents = "<sup>[return]</sup>",
.header_id_prefix = null,
.header_id_suffix = null,
},
.toc_marker = 0,
.header_count = 0,
.current_level = 0,
.toc = try Buffer.init(a, ""),
.renderer = Renderer{
.blockCodeFn = blockCode,
.blockQuoteFn = blockQuote,
.blockHtmlFn = blockQuote,
.headerFn = header,
.hruleFn = hrule,
.listFn = list,
.listItemFn = listItem,
.paragraphFn = paragraph,
.tableFn = table,
.tableRowFn = tableRow,
.tableHeaderCellFn = tableHeaderCell,
.tableCellFn = tableCell,
.footnotesFn = footnotes,
.footnoteItemFn = footnoteItem,
.titleBlockFn = titleBlock,
.autoLinkFn = autoLink,
.codeSpanFn = codeSpan,
.doubleEmphasisFn = doubleEmphasis,
.emphasisFn = emphasis,
.imageFn = image,
.lineBreakFn = lineBreak,
.linkFn = link,
.rawHtmlTagFn = rawHtmlTag,
.tripleEmphasisFn = tripleEmphasis,
.strikeThroughFn = strikeThrough,
.footnoteRefFn = footnoteRef,
.entityFn = entity,
.normalTextFn = normalText,
.documentHeaderFn = documentHeader,
.documentFooterFn = documentFooter,
.getFlagsFn = getFlags,
},
};
}
fn escapeChar(ch: u8) bool {
return switch (ch) {
'"', '&', '<', '>' => true,
else => false,
};
}
fn escapeSingleChar(buf: *Buffer, char: u8) !void {
switch (char) {
'"' => {
try buf.append(""");
},
'&' => {
try buf.append("&");
},
'<' => {
try buf.append("<");
},
'>' => {
try buf.append(">");
},
else => {},
}
}
fn attrEscape(buf: *Buffer, src: []const u8) !void {
var o: usize = 0;
for (src) |s, i| {
if (escapeChar(s)) {
if (i > o) {
try buf.append(src[o..i]);
}
o = i + 1;
try escapeSingleChar(buf, s);
}
}
if (o < src.len) {
try buf.append(src[o..]);
}
}
// naiveReplace simple replacing occurance of orig ,with with contents while
// writing the result to buf.
// Not optimized.
fn naiveReplace(buf: *Buffer, src: []const u8, orig: []const u8, with: []const u8) !void {
if (src.len < orig.len) return;
var s = src;
var start: usize = 0;
while (orig.len < s.len) {
if (mem.indexOf(u8, s, orig)) |idx| {
try buf.append(s[start..idx]);
try buf.append(with);
start += idx + with.len;
} else {
break;
}
}
if (start < s.len) {
try buf.append(s[start..]);
}
}
fn titleBlock(r: *Renderer, buf: *Buffer, text: []const u8) !void {
try buf.append("<h1 class=\"title\">");
const txt = mem.trimLeft(u8, text, "% ");
try naiveReplace(buf, txt, "\n% ", "\n");
try buf.append("\n</h1>");
}
fn doubleSpace(buf: *Buffer) !void {
if (buf.len() > 0) {
try buf.appendByte('\n');
}
}
fn getHeaderID(self: *HTML) i64 {
const id = self.header_count;
self.header_count += 1;
return id;
}
fn printBuffer(buf: *Buffer, comptime fmt: []const u8, args: ...) !void {
var stream = &io.BufferOutStream.init(buf).stream;
try stream.print(fmt, args);
}
fn header(
r: *Renderer,
buf: *Buffer,
text: *TextIter,
level: usize,
id: ?[]const u8,
) !void {
const marker = buf.len();
try doubleSpace(buf);
const self = @fieldParentPtr(HTML, "renderer", r);
var stream = &io.BufferOutStream.init(buf).stream;
const hid = ID.init(
id,
self.params.header_id_prefix,
self.params.header_id_suffix,
self.getHeaderID(),
self.flags & HTML_TOC != 0,
);
if (hid.valid()) {
try stream.print("<{} id=\"{}\"", level, hid);
} else {
try stream.print("<{}", level);
}
const toc_marker = buf.len();
if (!text.text()) {
try buf.resize(marker);
return;
}
try stream.print("</h{}>\n", level);
}
fn blockHtml(r: *Renderer, buf: *Buffer, text: []const u8) !void {
const self = @fieldParentPtr(HTML, "renderer", r);
if (self.flags & HTML_SKIP_HTML != 0) {
return;
}
try doubleSpace(buf);
try buf.append(text);
try buf.appendByte('\n');
}
fn hrule(r: *Renderer, buf: *Buffer) !void {
const self = @fieldParentPtr(HTML, "renderer", r);
try doubleSpace(buf);
try buf.append("<hr");
try buf.append(self.close_tag);
try buf.appendByte('\n');
}
fn blockCode(
r: *Renderer,
buf: *Buffer,
text: []const u8,
info: []const u8,
) !void {
try doubleSpace(buf);
const self = @fieldParentPtr(HTML, "renderer", r);
var end_of_lang: usize = 0;
if (mem.indexOfAny(u8, info, "\t ")) |idx| {
end_of_lang = idx;
}
const lang = if (end_of_lang != 0) info[0..end_of_lang] else "";
if (lang.len == 0 or lang[0] == '.') {
try buf.append("<pre><code>");
} else {
try buf.append("<pre><code class=\"language-)");
try attrEscape(buf, lang);
try buf.append("\">");
}
try buf.append(text);
try buf.append("</code></pre>\n");
}
fn blockQuote(
r: *Renderer,
buf: *Buffer,
text: []const u8,
) !void {
try doubleSpace(buf);
try buf.append("<blockquote>\n");
try buf.append(text);
try buf.append("</blockquote>\n");
}
fn table(
r: *Renderer,
buf: *Buffer,
table_header: []const u8,
body: []const u8,
colum_data: []const usize,
) !void {
try doubleSpace(buf);
try buf.append("<table>\n<thead>\n");
try buf.append(table_header);
try buf.append("</thead>\n\n<tbody>\n");
try buf.append(body);
try buf.append("</tbody>\n</table>\n");
}
fn tableRow(
r: *Renderer,
buf: *Buffer,
text: []const u8,
) !void {
try doubleSpace(buf);
try buf.append("<tr>\n");
try buf.append(text);
try buf.append("\n</tr>\n");
}
fn tableHeaderCell(
r: *Renderer,
buf: *Buffer,
text: []const u8,
alignment: usize,
) !void {
try doubleSpace(buf);
switch (alignment) {
TABLE_ALIGNMENT_LEFT => {
try buf.append("<th align=\"left\">");
},
TABLE_ALIGNMENT_RIGHT => {
try buf.append("<th align=\"right\">");
},
TABLE_ALIGNMENT_CENTER => {
try buf.append("<th align=\"center\">");
},
else => {
try buf.append("<th>");
},
}
try buf.append(text);
try buf.append("</th>");
}
fn tableCell(
r: *Renderer,
buf: *Buffer,
text: []const u8,
alignment: usize,
) !void {
try doubleSpace(buf);
switch (alignment) {
TABLE_ALIGNMENT_LEFT => {
try buf.append("<td align=\"left\">");
},
TABLE_ALIGNMENT_RIGHT => {
try buf.append("<td align=\"right\">");
},
TABLE_ALIGNMENT_CENTER => {
try buf.append("<td align=\"center\">");
},
else => {
try buf.append("<td>");
},
}
try buf.append(text);
try buf.append("</td>");
}
fn footnotes(
r: *Renderer,
buf: *Buffer,
text: *TextIter,
) !void {
try buf.append("<div class=\"footnotes\">\n");
try r.hrule(buf);
try r.list(buf, text, LIST_TYPE_ORDERED);
try buf.append("</div>\n");
}
fn slugify(buf: *Buffer, src: []const u8) !void {
if (src.len == 0) return;
const m = buf.len();
try buf.resize(m + src.len);
var s = buf.toSlice()[m..];
var sym = false;
for (src) |ch, i| {
if (ascii.isAlNum(ch)) {
s[i] = ch;
} else {
s[i] = '-';
}
}
}
fn footnoteItem(
r: *Renderer,
buf: *Buffer,
name: []const u8,
text: []const u8,
flags: usize,
) !void {
if ((flags & LIST_ITEM_CONTAINS_BLOCK != 0) or (flags & LIST_ITEM_BEGINNING_OF_LIST != 0)) {
try doubleSpace(buf);
}
const self = @fieldParentPtr(HTML, "renderer", r);
try buf.append("<li id=\"fn:");
if (self.params.footnote_anchor_prefix) |v| {
try buf.append(v);
}
try slugify(buf, name);
try buf.appendByte('>');
try buf.append(text);
if (self.flags & HTML_FOOTNOTE_RETURN_LINKS != 0) {
try buf.append(" <a class=\"footnote-return\" href=\"#fnref:");
if (self.params.footnote_anchor_prefix) |v| {
try buf.append(v);
}
try slugify(buf, name);
try buf.appendByte('>');
if (self.params.footnote_return_link_contents) |v| {
try buf.append(v);
}
try buf.append("</a>");
}
try buf.append("</li>\n");
}
fn list(
r: *Renderer,
buf: *Buffer,
text: *TextIter,
flags: usize,
) !void {
const marker = buf.len();
try doubleSpace(buf);
if (flags & LIST_TYPE_DEFINITION != 0) {
try buf.append("<dl>");
} else if (flags & LIST_TYPE_ORDERED != 0) {
try buf.append("<oll>");
} else {
try buf.append("<ul>");
}
if (!text.text()) {
try buf.resize(marker);
}
if (flags & LIST_TYPE_DEFINITION != 0) {
try buf.append("</dl>\n");
} else if (flags & LIST_TYPE_ORDERED != 0) {
try buf.append("</oll>\n");
} else {
try buf.append("</ul>\n");
}
}
fn listItem(
r: *Renderer,
buf: *Buffer,
text: []const u8,
flags: usize,
) !void {
if ((flags & LIST_ITEM_CONTAINS_BLOCK != 0 and
flags & LIST_TYPE_DEFINITION != 0) or
flags & LIST_ITEM_BEGINNING_OF_LIST != 0)
{
try doubleSpace(buf);
}
if (flags & LIST_TYPE_TERM != 0) {
try buf.append("<dt>");
} else if (flags & LIST_TYPE_DEFINITION != 0) {
try buf.append("<dd>");
} else {
try buf.append("<li>");
}
try buf.append(text);
if (flags & LIST_TYPE_TERM != 0) {
try buf.append("</dt>\n");
} else if (flags & LIST_TYPE_DEFINITION != 0) {
try buf.append("</dd>\n");
} else {
try buf.append("</li>\n");
}
}
fn paragraph(
r: *Renderer,
buf: *Buffer,
text: *TextIter,
) !void {
const marker = buf.len();
try doubleSpace(buf);
try buf.append("<p>");
if (!text.text()) {
try buf.resize(marker);
return;
}
try buf.append("</p>\n");
}
fn autoLink(
r: *Renderer,
buf: *Buffer,
link_: []const u8,
kind: usize,
) !void {
const self = @fieldParentPtr(HTML, "renderer", r);
if (self.flags & HTML_SAFELINK != 0 and !Util.isSafeLink(link_) and
kind != LINK_TYPE_EMAIL)
{
try buf.append("<tt>");
try attrEscape(buf, link_);
try buf.append("</tt>");
return;
}
try buf.append("<a href=\"");
if (kind == LINK_TYPE_EMAIL) {
try buf.append("mailto:");
} else {
try self.maybeWriteAbsolutePrefix(buf, link_);
}
try attrEscape(buf, link_);
var no_follow = false;
var no_referer = false;
if (self.flags & HTML_NOFOLLOW_LINKS != 0 and !Util.isRelativeLink(link_)) {
no_follow = true;
}
if (self.flags & HTML_NOREFERRER_LINKS != 0 and !Util.isRelativeLink(link_)) {
no_referer = true;
}
if (no_follow or no_referer) {
try buf.append("\" rel=\"");
if (no_follow) {
try buf.append("nofollow");
}
if (no_referer) {
try buf.append(" noreferrer");
}
try buf.appendByte('"');
}
if (self.flags & HTML_HREF_TARGET_BLANK != 0 and !Util.isRelativeLink(link_)) {
try buf.append("\" target=\"_blank");
}
// Pretty print: if we get an email address as
// an actual URI, e.g. `mailto:foo@bar.com`, we don't
// want to print the `mailto:` prefix
const mailto = "mailto://";
if (mem.startsWith(u8, link_, mailto)) {
try attrEscape(buf, link_[mailto.len..]);
} else if (mem.startsWith(u8, link_, mailto[0 .. mailto.len - 2])) {
try attrEscape(buf, link_[mailto.len - 2 ..]);
} else {
try attrEscape(buf, link_);
}
try buf.append("</a>");
}
fn maybeWriteAbsolutePrefix(
self: *HTML,
buf: *Buffer,
link_: []const u8,
) !void {
if (self.params.absolute_prefix != null and Util.isRelativeLink(link_) and
link_[0] != '.')
{
try buf.append(self.params.absolute_prefix.?);
if (link_[0] != '/') {
try buf.appendByte('/');
}
}
}
fn codeSpan(
r: *Renderer,
buf: *Buffer,
text: []const u8,
) !void {
try buf.append("<code>");
try attrEscape(buf, text);
try buf.append("</code>");
}
fn doubleEmphasis(
r: *Renderer,
buf: *Buffer,
text: []const u8,
) !void {
try buf.append("<strong>");
try attrEscape(buf, text);
try buf.append("</strong>");
}
fn emphasis(
r: *Renderer,
buf: *Buffer,
text: []const u8,
) !void {
if (text.len == 0) return;
try buf.append("<em>");
try attrEscape(buf, text);
try buf.append("</em>");
}
fn image(
r: *Renderer,
buf: *Buffer,
link_: []const u8,
title: ?[]const u8,
alt: ?[]const u8,
) !void {
const self = @fieldParentPtr(HTML, "renderer", r);
if (self.flags & HTML_SKIP_IMAGES != 0) return;
try buf.append("<img src=\"");
try self.maybeWriteAbsolutePrefix(buf, link_);
try attrEscape(buf, link_);
try buf.append("\" alt=\"");
if (alt) |v| {
try attrEscape(buf, v);
}
if (title) |v| {
try buf.append("\" title=\"");
try attrEscape(buf, v);
}
try buf.appendByte('"');
try buf.append(self.close_tag);
}
fn lineBreak(
r: *Renderer,
buf: *Buffer,
) !void {
const self = @fieldParentPtr(HTML, "renderer", r);
try buf.append("<br");
try buf.append(self.close_tag);
try buf.appendByte('\n');
}
fn link(
r: *Renderer,
buf: *Buffer,
link_: []const u8,
title: ?[]const u8,
content: []const u8,
) !void {
const self = @fieldParentPtr(HTML, "renderer", r);
if (self.flags & HTML_SKIP_LINKS != 0) {
try buf.append("<tt>");
try attrEscape(buf, content);
try buf.append("</tt>");
return;
}
try buf.append("<a href=\"");
try self.maybeWriteAbsolutePrefix(buf, link_);
try attrEscape(buf, link_);
if (title) |v| {
try buf.append("\" title=\"");
try attrEscape(buf, v);
}
var no_follow = false;
var no_referer = false;
if (self.flags & HTML_NOFOLLOW_LINKS != 0 and !Util.isRelativeLink(link_)) {
no_follow = true;
}
if (self.flags & HTML_NOREFERRER_LINKS != 0 and !Util.isRelativeLink(link_)) {
no_referer = true;
}
if (no_follow or no_referer) {
try buf.append("\" rel=\"");
if (no_follow) {
try buf.append("nofollow");
}
if (no_referer) {
try buf.append(" noreferrer");
}
try buf.appendByte('"');
}
if (self.flags & HTML_HREF_TARGET_BLANK != 0 and !Util.isRelativeLink(link_)) {
try buf.append("\" target=\"_blank");
}
try buf.append("\">");
try buf.append(content);
try buf.append("</a>");
}
fn rawHtmlTag(
r: *Renderer,
buf: *Buffer,
text: []const u8,
) !void {
const self = @fieldParentPtr(HTML, "renderer", r);
if (self.flags & HTML_SKIP_HTML != 0) {
return;
}
if (self.flags & HTML_SKIP_STYLE != 0 and Util.isHtmlTag(text, "style")) {
return;
}
if (self.flags & HTML_SKIP_LINKS != 0 and Util.isHtmlTag(text, "a")) {
return;
}
if (self.flags & HTML_SKIP_IMAGES != 0 and Util.isHtmlTag(text, "img")) {
return;
}
try buf.append(text);
}
fn tripleEmphasis(
r: *Renderer,
buf: *Buffer,
text: []const u8,
) !void {
try buf.append("<strong><em>");
try buf.append(text);
try buf.append("</em></strong>");
}
fn strikeThrough(
r: *Renderer,
buf: *Buffer,
text: []const u8,
) !void {
try buf.append("<del>");
try buf.append(text);
try buf.append("</del>");
}
fn footnoteRef(
r: *Renderer,
buf: *Buffer,
ref: []const u8,
id: usize,
) !void {
const self = @fieldParentPtr(HTML, "renderer", r);
try buf.append("<sup class=\"footnote-ref\" id=\"fnref:");
if (self.params.footnote_anchor_prefix) |v| {
try buf.append(v);
}
try slugify(buf, ref);
try buf.append("\"><a href=\"#fn:");
if (self.params.footnote_anchor_prefix) |v| {
try buf.append(v);
}
try slugify(buf, ref);
try buf.append("\">");
try printBuffer(buf, "{}", id);
try buf.append("</a></sup>");
}
fn entity(
r: *Renderer,
buf: *Buffer,
text: []const u8,
) !void {
try buf.append(text);
}
fn normalText(
r: *Renderer,
buf: *Buffer,
text: []const u8,
) !void {
try attrEscape(buf, text);
}
fn documentHeader(
r: *Renderer,
buf: *Buffer,
) anyerror!void {
//noop
}
fn documentFooter(
r: *Renderer,
buf: *Buffer,
) anyerror!void {
//noop
}
fn getFlags(
r: *Renderer,
) usize {
const self = @fieldParentPtr(HTML, "renderer", r);
return self.flags;
}
};
pub const Util = struct {
const valid_urls = [_][]const u8{
"http://", "https://", "ftp://", "mailto://",
};
const valid_paths = [_][]const u8{
"/", "https://", "./", "../",
};
pub fn isSafeLink(link: []const u8) bool {
for (valid_paths) |p| {
if (mem.startsWith(u8, link, p)) {
if (link.len == p.len) {
return true;
}
if (ascii.isAlNum(link[p.len])) {
return true;
}
}
}
for (valid_urls) |u| {
if (link.len > u.len and eqlLower(link[0..u.len], u) and ascii.isAlNum(link[u.len])) {
return true;
}
}
return false;
}
/// eqlLower compares a, and b with all caharacters from aconverted to lower
/// case.
pub fn eqlLower(a: []const u8, b: []const u8) bool {
if (a.len != b.len) return false;
for (b) |v, i| {
if (ascii.toLower(a[i]) != v) return false;
}
return true;
}
pub fn isRelativeLink(link: []const u8) bool {
if (link.len == 0) return false;
if (link[0] == '#') return true;
// link begin with '/' but not '//', the second maybe a protocol relative link
if (link.len >= 2 and link[0] == '/' and link[1] != '/') {
return true;
}
// only the root '/'
if (link.len == 1 and link[0] == '/') {
return true;
}
// current directory : begin with "./"
if (mem.startsWith(u8, link, "./")) {
return true;
}
// parent directory : begin with "../"
if (mem.startsWith(u8, link, "../")) {
return true;
}
return false;
}
pub fn isHtmlTag(
tag: []const u8,
tag_name: []const u8,
) bool {
if (findHtmlTagPos(tag, tag_name)) |_| return true;
return false;
}
pub fn findHtmlTagPos(
tag: []const u8,
tag_name: []const u8,
) ?usize {
var t = tag;
var i: usize = 0;
if (i < tag.len and tag[0] != '<') return null;
i += 1;
i = skipSpace(t, i);
if (i < tag.len and tag[0] == '/') i += 1;
i = skipSpace(t, i);
var j: usize = 0;
while (i < t.len) : ({
i += 1;
j += 1;
}) {
if (j >= tag_name.len) {
break;
}
if (ascii.toLower(t[i]) != tag_name[j]) {
return null;
}
}
if (i == t.len) {
return null;
}
const a = skipUntilCharIgnoreQuotes(t, i, '>');
if (a > i) return a;
return null;
}
fn skipUntilCharIgnoreQuotes(html: []const u8, start: usize, char: u8) usize {
var s = false;
var d = false;
var g = false;
var i = start;
while (i < html.len) {
if (html[i] == char and !s and !d and !g) {
return i;
} else if (html[i] == '\'') {
s = !s;
} else if (html[i] == '"') {
d = !d;
} else if (html[i] == '`') {
g = !g;
}
i += 1;
}
return start;
}
pub fn skipSpace(s: []const u8, at: usize) usize {
var v = s;
var i = at;
while (i < s.len) : (i += 1) {
if (!ascii.isSpace(s[i])) {
break;
}
}
return i;
}
};
pub const OkMap = std.AutoHash([]const u8, void);
pub const Parser = struct {
allocator: *Allocator,
r: *Renderer,
refs: ReferenceMap,
inline_callback: [256]?fn (
p: *Parser,
buf: *Buffer,
data: []const u8,
offset: usize,
) !usize,
flags: usize,
nesting: usize,
max_nesting: usize,
inside_link: bool,
notes: std.ArrayList(*Reference),
notes_record: OkMap,
pub const ReferenceMap = std.AutoHash([]const u8, *Reference);
pub const Reference = struct {
link: ?[]const u8,
title: ?[]const u8,
note_id: usize,
has_block: bool,
text: ?[]const u8,
};
fn isSpace(c: u8) bool {
return switch (c) {
' ', '\t', '\n', '\r', '\f', '\v' => true,
else => false,
};
}
// INLINE
fn inlineFn(
self: *Parser,
buf: *Buffer,
data: []const u8,
) !void {
if (self.nesting >= self.max_nesting) {
return;
}
self.nesting += 1;
var i: usize = 0;
var end: usize = 0;
while (i < data.len) {
while (end < data.len and self.inline_callback[data[end]] == null) {
end += 1;
}
try self.r.normalText(buf, data[i..end]);
if (end >= data.len) {
break;
}
i = end;
const h = self.inline_callback[data[end]].?;
const c = try h(self, buf, data, i);
if (c == 0) {
end = i + 1;
} else {
i += c;
end = i;
}
}
self.nesting -= 1;
}
fn helperFindEmphChar(
data: []const u8,
c: u8,
) usize {
var i: usize = 0;
while (i < data.len) {
while (i < data.len and data[i] != c and data[i] != '`' and data[i] != '[') {
i += 1;
}
if (i >= data.len) {
return 0;
}
if (i != 0 and data[i - 1] == '\\') {
i += 1;
continue;
}
if (data[i] == c) {
return i;
}
if (data[i] == '`') {
var tmp: usize = 0;
i += 1;
while (i < data.len and data[i] != '`') {
if (tmp == 0 and data[i] == c) {
tmp = i;
}
i += 1;
}
if (i >= data.len) {
return tmp;
}
i += 1;
} else if (data[i] == '[') {
var tmp: usize = 0;
i += 1;
while (i < data.len and data[i] != ']') {
if (tmp == 0 and data[i] == c) {
tmp = i;
}
i += 1;
}
i += 1;
while (i < data.len and (data[i] == ' ' or data[i] == '\n')) {
i += 1;
}
if (i >= data.len) return tmp;
if (data[i] != '[' and data[i] != '(') {
if (tmp > 0) return tmp;
continue;
}
var cc = data[i];
while (i < data.len and data[i] != cc) {
if (tmp == 0 and data[i] == c) {
return i;
}
i += 1;
}
if (i >= data.len) {
return tmp;
}
i += 1;
}
}
return 0;
}
fn helperEmphasis(
self: *Parser,
buf: *Buffer,
data: []const u8,
c: u8,
) !usize {
var i: usize = 0;
if (data.len > 1 and data[0] == c and data[1] == c) {
i = 1;
}
while (i < data.len) {
const l = helperFindEmphChar(data[i..], c);
if (l == 0) return 0;
i += l;
if (i >= data.len) return 0;
if (i + 1 < data.len and data[i + 1] == c) {
i += 1;
continue;
}
if (data[i] == c and isSpace(data[i - 1])) {
if (self.flags & EXTENSION_NO_INTRA_EMPHASIS != 0) {
if (!(i + 1 == data.len or isspace(data[i + 1]) or ispunct(data[i + 1]))) {
continue;
}
}
var w = &try Buffer.init(self.allocator, "");
try self.inlineFn(w, data[0..i]);
try self.r.empasis(buf, w.toSlice());
w.deinit();
return i + 1;
}
}
return 0;
}
fn helperDoubleEmphasis(
self: *Parser,
buf: *Buffer,
data: []const u8,
c: u8,
) !usize {
var i: usize = 0;
while (i < data.len) {
const l = helperFindEmphChar(data[i..], c);
if (l == 0) return 0;
i += 1;
if (i + 1 < data.len and data[i] == c and data[i + 1] == c and i > 0 and !isSpace(data[i - 1])) {
try self.inlineFn(w, data[i..]);
var w = &try Buffer.init(self.allocator, "");
if (w.len() > 0) {
if (c == '~') {
try self.r.strikeThrough(buf, w.toSlice());
} else {
try self.r.doubleEmphasis(buf, w.toSlice());
}
}
w.deinit();
return i += 2;
}
i += 1;
}
}
fn empasis(
self: *Parser,
buf: *Buffer,
text: []const u8,
offset: usize,
) !usize {
var data = text[offset..];
const c = data[0];
}
};
test "HTML.test" {
var a = std.debug.global_allocator;
var h = try HTML.init(a);
}
| 30.414917 | 122 | 0.494179 |
3fd5cd5f948c6c442f6dd13b126f17a764746609 | 58,109 | zig | Zig | lib/std/target.zig | AODQ/zig | 73d0fa9a9894abf3621eb273708972a783ea650f | [
"MIT"
] | null | null | null | lib/std/target.zig | AODQ/zig | 73d0fa9a9894abf3621eb273708972a783ea650f | [
"MIT"
] | null | null | null | lib/std/target.zig | AODQ/zig | 73d0fa9a9894abf3621eb273708972a783ea650f | [
"MIT"
] | null | null | null | // SPDX-License-Identifier: MIT
// Copyright (c) 2015-2021 Zig Contributors
// This file is part of [zig](https://ziglang.org/), which is MIT licensed.
// The MIT license requires this copyright notice to be included in all copies
// and substantial portions of the software.
const std = @import("std.zig");
const mem = std.mem;
const builtin = std.builtin;
const Version = std.builtin.Version;
/// TODO Nearly all the functions in this namespace would be
/// better off if https://github.com/ziglang/zig/issues/425
/// was solved.
pub const Target = struct {
cpu: Cpu,
os: Os,
abi: Abi,
pub const Os = struct {
tag: Tag,
version_range: VersionRange,
pub const Tag = enum {
freestanding,
ananas,
cloudabi,
dragonfly,
freebsd,
fuchsia,
ios,
kfreebsd,
linux,
lv2,
macos,
netbsd,
openbsd,
solaris,
windows,
zos,
haiku,
minix,
rtems,
nacl,
aix,
cuda,
nvcl,
amdhsa,
ps4,
elfiamcu,
tvos,
watchos,
mesa3d,
contiki,
amdpal,
hermit,
hurd,
wasi,
emscripten,
uefi,
opencl,
glsl450,
vulkan,
other,
pub fn isDarwin(tag: Tag) bool {
return switch (tag) {
.ios, .macos, .watchos, .tvos => true,
else => false,
};
}
pub fn dynamicLibSuffix(tag: Tag) [:0]const u8 {
if (tag.isDarwin()) {
return ".dylib";
}
switch (tag) {
.windows => return ".dll",
else => return ".so",
}
}
pub fn defaultVersionRange(tag: Tag) Os {
return .{
.tag = tag,
.version_range = VersionRange.default(tag),
};
}
};
/// Based on NTDDI version constants from
/// https://docs.microsoft.com/en-us/cpp/porting/modifying-winver-and-win32-winnt
pub const WindowsVersion = enum(u32) {
nt4 = 0x04000000,
win2k = 0x05000000,
xp = 0x05010000,
ws2003 = 0x05020000,
vista = 0x06000000,
win7 = 0x06010000,
win8 = 0x06020000,
win8_1 = 0x06030000,
win10 = 0x0A000000, //aka win10_th1
win10_th2 = 0x0A000001,
win10_rs1 = 0x0A000002,
win10_rs2 = 0x0A000003,
win10_rs3 = 0x0A000004,
win10_rs4 = 0x0A000005,
win10_rs5 = 0x0A000006,
win10_19h1 = 0x0A000007,
win10_vb = 0x0A000008, //aka win10_19h2
win10_mn = 0x0A000009, //aka win10_20h1
win10_fe = 0x0A00000A, //aka win10_20h2
_,
/// Latest Windows version that the Zig Standard Library is aware of
pub const latest = WindowsVersion.win10_fe;
/// Compared against build numbers reported by the runtime to distinguish win10 versions,
/// where 0x0A000000 + index corresponds to the WindowsVersion u32 value.
pub const known_win10_build_numbers = [_]u32{
10240, //win10 aka win10_th1
10586, //win10_th2
14393, //win10_rs1
15063, //win10_rs2
16299, //win10_rs3
17134, //win10_rs4
17763, //win10_rs5
18362, //win10_19h1
18363, //win10_vb aka win10_19h2
19041, //win10_mn aka win10_20h1
19042, //win10_fe aka win10_20h2
};
/// Returns whether the first version `self` is newer (greater) than or equal to the second version `ver`.
pub fn isAtLeast(self: WindowsVersion, ver: WindowsVersion) bool {
return @enumToInt(self) >= @enumToInt(ver);
}
pub const Range = struct {
min: WindowsVersion,
max: WindowsVersion,
pub fn includesVersion(self: Range, ver: WindowsVersion) bool {
return @enumToInt(ver) >= @enumToInt(self.min) and @enumToInt(ver) <= @enumToInt(self.max);
}
/// Checks if system is guaranteed to be at least `version` or older than `version`.
/// Returns `null` if a runtime check is required.
pub fn isAtLeast(self: Range, ver: WindowsVersion) ?bool {
if (@enumToInt(self.min) >= @enumToInt(ver)) return true;
if (@enumToInt(self.max) < @enumToInt(ver)) return false;
return null;
}
};
/// This function is defined to serialize a Zig source code representation of this
/// type, that, when parsed, will deserialize into the same data.
pub fn format(
self: WindowsVersion,
comptime fmt: []const u8,
options: std.fmt.FormatOptions,
out_stream: anytype,
) !void {
if (fmt.len > 0 and fmt[0] == 's') {
if (@enumToInt(self) >= @enumToInt(WindowsVersion.nt4) and @enumToInt(self) <= @enumToInt(WindowsVersion.latest)) {
try std.fmt.format(out_stream, ".{s}", .{@tagName(self)});
} else {
// TODO this code path breaks zig triples, but it is used in `builtin`
try std.fmt.format(out_stream, "@intToEnum(Target.Os.WindowsVersion, 0x{X:0>8})", .{@enumToInt(self)});
}
} else {
if (@enumToInt(self) >= @enumToInt(WindowsVersion.nt4) and @enumToInt(self) <= @enumToInt(WindowsVersion.latest)) {
try std.fmt.format(out_stream, "WindowsVersion.{s}", .{@tagName(self)});
} else {
try std.fmt.format(out_stream, "WindowsVersion(0x{X:0>8})", .{@enumToInt(self)});
}
}
}
};
pub const LinuxVersionRange = struct {
range: Version.Range,
glibc: Version,
pub fn includesVersion(self: LinuxVersionRange, ver: Version) bool {
return self.range.includesVersion(ver);
}
/// Checks if system is guaranteed to be at least `version` or older than `version`.
/// Returns `null` if a runtime check is required.
pub fn isAtLeast(self: LinuxVersionRange, ver: Version) ?bool {
return self.range.isAtLeast(ver);
}
};
/// The version ranges here represent the minimum OS version to be supported
/// and the maximum OS version to be supported. The default values represent
/// the range that the Zig Standard Library bases its abstractions on.
///
/// The minimum version of the range is the main setting to tweak for a target.
/// Usually, the maximum target OS version will remain the default, which is
/// the latest released version of the OS.
///
/// To test at compile time if the target is guaranteed to support a given OS feature,
/// one should check that the minimum version of the range is greater than or equal to
/// the version the feature was introduced in.
///
/// To test at compile time if the target certainly will not support a given OS feature,
/// one should check that the maximum version of the range is less than the version the
/// feature was introduced in.
///
/// If neither of these cases apply, a runtime check should be used to determine if the
/// target supports a given OS feature.
///
/// Binaries built with a given maximum version will continue to function on newer
/// operating system versions. However, such a binary may not take full advantage of the
/// newer operating system APIs.
///
/// See `Os.isAtLeast`.
pub const VersionRange = union {
none: void,
semver: Version.Range,
linux: LinuxVersionRange,
windows: WindowsVersion.Range,
/// The default `VersionRange` represents the range that the Zig Standard Library
/// bases its abstractions on.
pub fn default(tag: Tag) VersionRange {
switch (tag) {
.freestanding,
.ananas,
.cloudabi,
.fuchsia,
.kfreebsd,
.lv2,
.solaris,
.zos,
.haiku,
.minix,
.rtems,
.nacl,
.aix,
.cuda,
.nvcl,
.amdhsa,
.ps4,
.elfiamcu,
.mesa3d,
.contiki,
.amdpal,
.hermit,
.hurd,
.wasi,
.emscripten,
.uefi,
.opencl, // TODO: OpenCL versions
.glsl450, // TODO: GLSL versions
.vulkan,
.other,
=> return .{ .none = {} },
.freebsd => return .{
.semver = Version.Range{
.min = .{ .major = 12, .minor = 0 },
.max = .{ .major = 13, .minor = 0 },
},
},
.macos => return .{
.semver = .{
.min = .{ .major = 10, .minor = 13 },
.max = .{ .major = 11, .minor = 2 },
},
},
.ios => return .{
.semver = .{
.min = .{ .major = 12, .minor = 0 },
.max = .{ .major = 13, .minor = 4, .patch = 0 },
},
},
.watchos => return .{
.semver = .{
.min = .{ .major = 6, .minor = 0 },
.max = .{ .major = 6, .minor = 2, .patch = 0 },
},
},
.tvos => return .{
.semver = .{
.min = .{ .major = 13, .minor = 0 },
.max = .{ .major = 13, .minor = 4, .patch = 0 },
},
},
.netbsd => return .{
.semver = .{
.min = .{ .major = 8, .minor = 0 },
.max = .{ .major = 9, .minor = 1 },
},
},
.openbsd => return .{
.semver = .{
.min = .{ .major = 6, .minor = 8 },
.max = .{ .major = 6, .minor = 9 },
},
},
.dragonfly => return .{
.semver = .{
.min = .{ .major = 5, .minor = 8 },
.max = .{ .major = 6, .minor = 0 },
},
},
.linux => return .{
.linux = .{
.range = .{
.min = .{ .major = 3, .minor = 16 },
.max = .{ .major = 5, .minor = 5, .patch = 5 },
},
.glibc = .{ .major = 2, .minor = 17 },
},
},
.windows => return .{
.windows = .{
.min = .win8_1,
.max = WindowsVersion.latest,
},
},
}
}
};
pub const TaggedVersionRange = union(enum) {
none: void,
semver: Version.Range,
linux: LinuxVersionRange,
windows: WindowsVersion.Range,
};
/// Provides a tagged union. `Target` does not store the tag because it is
/// redundant with the OS tag; this function abstracts that part away.
pub fn getVersionRange(self: Os) TaggedVersionRange {
switch (self.tag) {
.linux => return TaggedVersionRange{ .linux = self.version_range.linux },
.windows => return TaggedVersionRange{ .windows = self.version_range.windows },
.freebsd,
.macos,
.ios,
.tvos,
.watchos,
.netbsd,
.openbsd,
.dragonfly,
=> return TaggedVersionRange{ .semver = self.version_range.semver },
else => return .none,
}
}
/// Checks if system is guaranteed to be at least `version` or older than `version`.
/// Returns `null` if a runtime check is required.
pub fn isAtLeast(self: Os, comptime tag: Tag, version: anytype) ?bool {
if (self.tag != tag) return false;
return switch (tag) {
.linux => self.version_range.linux.isAtLeast(version),
.windows => self.version_range.windows.isAtLeast(version),
else => self.version_range.semver.isAtLeast(version),
};
}
/// On Darwin, we always link libSystem which contains libc.
/// Similarly on FreeBSD and NetBSD we always link system libc
/// since this is the stable syscall interface.
pub fn requiresLibC(os: Os) bool {
return switch (os.tag) {
.freebsd,
.netbsd,
.macos,
.ios,
.tvos,
.watchos,
.dragonfly,
.openbsd,
.haiku,
=> true,
.linux,
.windows,
.freestanding,
.ananas,
.cloudabi,
.fuchsia,
.kfreebsd,
.lv2,
.solaris,
.zos,
.minix,
.rtems,
.nacl,
.aix,
.cuda,
.nvcl,
.amdhsa,
.ps4,
.elfiamcu,
.mesa3d,
.contiki,
.amdpal,
.hermit,
.hurd,
.wasi,
.emscripten,
.uefi,
.opencl,
.glsl450,
.vulkan,
.other,
=> false,
};
}
};
pub const aarch64 = @import("target/aarch64.zig");
pub const amdgpu = @import("target/amdgpu.zig");
pub const arm = @import("target/arm.zig");
pub const avr = @import("target/avr.zig");
pub const bpf = @import("target/bpf.zig");
pub const hexagon = @import("target/hexagon.zig");
pub const mips = @import("target/mips.zig");
pub const msp430 = @import("target/msp430.zig");
pub const nvptx = @import("target/nvptx.zig");
pub const powerpc = @import("target/powerpc.zig");
pub const riscv = @import("target/riscv.zig");
pub const sparc = @import("target/sparc.zig");
pub const spirv = @import("target/spirv.zig");
pub const systemz = @import("target/systemz.zig");
pub const ve = @import("target/ve.zig");
pub const wasm = @import("target/wasm.zig");
pub const x86 = @import("target/x86.zig");
pub const Abi = enum {
none,
gnu,
gnuabin32,
gnuabi64,
gnueabi,
gnueabihf,
gnux32,
gnuilp32,
code16,
eabi,
eabihf,
android,
musl,
musleabi,
musleabihf,
msvc,
itanium,
cygnus,
coreclr,
simulator,
macabi,
pub fn default(arch: Cpu.Arch, target_os: Os) Abi {
if (arch.isWasm()) {
return .musl;
}
switch (target_os.tag) {
.freestanding,
.ananas,
.cloudabi,
.dragonfly,
.lv2,
.solaris,
.zos,
.minix,
.rtems,
.nacl,
.aix,
.cuda,
.nvcl,
.amdhsa,
.ps4,
.elfiamcu,
.mesa3d,
.contiki,
.amdpal,
.hermit,
.other,
=> return .eabi,
.openbsd,
.macos,
.freebsd,
.ios,
.tvos,
.watchos,
.fuchsia,
.kfreebsd,
.netbsd,
.hurd,
.haiku,
.windows,
=> return .gnu,
.uefi => return .msvc,
.linux,
.wasi,
.emscripten,
=> return .musl,
.opencl, // TODO: SPIR-V ABIs with Linkage capability
.glsl450,
.vulkan,
=> return .none,
}
}
pub fn isGnu(abi: Abi) bool {
return switch (abi) {
.gnu, .gnuabin32, .gnuabi64, .gnueabi, .gnueabihf, .gnux32 => true,
else => false,
};
}
pub fn isMusl(abi: Abi) bool {
return switch (abi) {
.musl, .musleabi, .musleabihf => true,
else => false,
};
}
pub fn floatAbi(abi: Abi) FloatAbi {
return switch (abi) {
.gnueabihf,
.eabihf,
.musleabihf,
=> .hard,
else => .soft,
};
}
};
pub const ObjectFormat = enum {
coff,
pe,
elf,
macho,
wasm,
c,
spirv,
hex,
raw,
};
pub const SubSystem = enum {
Console,
Windows,
Posix,
Native,
EfiApplication,
EfiBootServiceDriver,
EfiRom,
EfiRuntimeDriver,
};
pub const Cpu = struct {
/// Architecture
arch: Arch,
/// The CPU model to target. It has a set of features
/// which are overridden with the `features` field.
model: *const Model,
/// An explicit list of the entire CPU feature set. It may differ from the specific CPU model's features.
features: Feature.Set,
pub const Feature = struct {
/// The bit index into `Set`. Has a default value of `undefined` because the canonical
/// structures are populated via comptime logic.
index: Set.Index = undefined,
/// Has a default value of `undefined` because the canonical
/// structures are populated via comptime logic.
name: []const u8 = undefined,
/// If this corresponds to an LLVM-recognized feature, this will be populated;
/// otherwise null.
llvm_name: ?[:0]const u8,
/// Human-friendly UTF-8 text.
description: []const u8,
/// Sparse `Set` of features this depends on.
dependencies: Set,
/// A bit set of all the features.
pub const Set = struct {
ints: [usize_count]usize,
pub const needed_bit_count = 288;
pub const byte_count = (needed_bit_count + 7) / 8;
pub const usize_count = (byte_count + (@sizeOf(usize) - 1)) / @sizeOf(usize);
pub const Index = std.math.Log2Int(std.meta.Int(.unsigned, usize_count * @bitSizeOf(usize)));
pub const ShiftInt = std.math.Log2Int(usize);
pub const empty = Set{ .ints = [1]usize{0} ** usize_count };
pub fn empty_workaround() Set {
return Set{ .ints = [1]usize{0} ** usize_count };
}
pub fn isEmpty(set: Set) bool {
return for (set.ints) |x| {
if (x != 0) break false;
} else true;
}
pub fn isEnabled(set: Set, arch_feature_index: Index) bool {
const usize_index = arch_feature_index / @bitSizeOf(usize);
const bit_index = @intCast(ShiftInt, arch_feature_index % @bitSizeOf(usize));
return (set.ints[usize_index] & (@as(usize, 1) << bit_index)) != 0;
}
/// Adds the specified feature but not its dependencies.
pub fn addFeature(set: *Set, arch_feature_index: Index) void {
const usize_index = arch_feature_index / @bitSizeOf(usize);
const bit_index = @intCast(ShiftInt, arch_feature_index % @bitSizeOf(usize));
set.ints[usize_index] |= @as(usize, 1) << bit_index;
}
/// Adds the specified feature set but not its dependencies.
pub fn addFeatureSet(set: *Set, other_set: Set) void {
set.ints = @as(std.meta.Vector(usize_count, usize), set.ints) |
@as(std.meta.Vector(usize_count, usize), other_set.ints);
}
/// Removes the specified feature but not its dependents.
pub fn removeFeature(set: *Set, arch_feature_index: Index) void {
const usize_index = arch_feature_index / @bitSizeOf(usize);
const bit_index = @intCast(ShiftInt, arch_feature_index % @bitSizeOf(usize));
set.ints[usize_index] &= ~(@as(usize, 1) << bit_index);
}
/// Removes the specified feature but not its dependents.
pub fn removeFeatureSet(set: *Set, other_set: Set) void {
set.ints = @as(std.meta.Vector(usize_count, usize), set.ints) &
~@as(std.meta.Vector(usize_count, usize), other_set.ints);
}
pub fn populateDependencies(set: *Set, all_features_list: []const Cpu.Feature) void {
@setEvalBranchQuota(1000000);
var old = set.ints;
while (true) {
for (all_features_list) |feature, index_usize| {
const index = @intCast(Index, index_usize);
if (set.isEnabled(index)) {
set.addFeatureSet(feature.dependencies);
}
}
const nothing_changed = mem.eql(usize, &old, &set.ints);
if (nothing_changed) return;
old = set.ints;
}
}
pub fn asBytes(set: *const Set) *const [byte_count]u8 {
return @ptrCast(*const [byte_count]u8, &set.ints);
}
pub fn eql(set: Set, other: Set) bool {
return mem.eql(usize, &set.ints, &other.ints);
}
};
pub fn feature_set_fns(comptime F: type) type {
return struct {
/// Populates only the feature bits specified.
pub fn featureSet(features: []const F) Set {
var x = Set.empty_workaround(); // TODO remove empty_workaround
for (features) |feature| {
x.addFeature(@enumToInt(feature));
}
return x;
}
/// Returns true if the specified feature is enabled.
pub fn featureSetHas(set: Set, feature: F) bool {
return set.isEnabled(@enumToInt(feature));
}
/// Returns true if any specified feature is enabled.
pub fn featureSetHasAny(set: Set, features: anytype) bool {
comptime std.debug.assert(std.meta.trait.isIndexable(@TypeOf(features)));
inline for (features) |feature| {
if (set.isEnabled(@enumToInt(@as(F, feature)))) return true;
}
return false;
}
/// Returns true if every specified feature is enabled.
pub fn featureSetHasAll(set: Set, features: anytype) bool {
comptime std.debug.assert(std.meta.trait.isIndexable(@TypeOf(features)));
inline for (features) |feature| {
if (!set.isEnabled(@enumToInt(@as(F, feature)))) return false;
}
return true;
}
};
}
};
pub const Arch = enum {
arm,
armeb,
aarch64,
aarch64_be,
aarch64_32,
arc,
avr,
bpfel,
bpfeb,
csky,
hexagon,
mips,
mipsel,
mips64,
mips64el,
msp430,
powerpc,
powerpcle,
powerpc64,
powerpc64le,
r600,
amdgcn,
riscv32,
riscv64,
sparc,
sparcv9,
sparcel,
s390x,
tce,
tcele,
thumb,
thumbeb,
i386,
x86_64,
xcore,
nvptx,
nvptx64,
le32,
le64,
amdil,
amdil64,
hsail,
hsail64,
spir,
spir64,
kalimba,
shave,
lanai,
wasm32,
wasm64,
renderscript32,
renderscript64,
ve,
// Stage1 currently assumes that architectures above this comment
// map one-to-one with the ZigLLVM_ArchType enum.
spu_2,
spirv32,
spirv64,
pub fn isX86(arch: Arch) bool {
return switch (arch) {
.i386, .x86_64 => true,
else => false,
};
}
pub fn isARM(arch: Arch) bool {
return switch (arch) {
.arm, .armeb => true,
else => false,
};
}
pub fn isThumb(arch: Arch) bool {
return switch (arch) {
.thumb, .thumbeb => true,
else => false,
};
}
pub fn isWasm(arch: Arch) bool {
return switch (arch) {
.wasm32, .wasm64 => true,
else => false,
};
}
pub fn isRISCV(arch: Arch) bool {
return switch (arch) {
.riscv32, .riscv64 => true,
else => false,
};
}
pub fn isMIPS(arch: Arch) bool {
return switch (arch) {
.mips, .mipsel, .mips64, .mips64el => true,
else => false,
};
}
pub fn isPPC(arch: Arch) bool {
return switch (arch) {
.powerpc, .powerpcle => true,
else => false,
};
}
pub fn isPPC64(arch: Arch) bool {
return switch (arch) {
.powerpc64, .powerpc64le => true,
else => false,
};
}
pub fn isSPARC(arch: Arch) bool {
return switch (arch) {
.sparc, .sparcel, .sparcv9 => true,
else => false,
};
}
pub fn isSPIRV(arch: Arch) bool {
return switch (arch) {
.spirv32, .spirv64 => true,
else => false,
};
}
pub fn parseCpuModel(arch: Arch, cpu_name: []const u8) !*const Cpu.Model {
for (arch.allCpuModels()) |cpu| {
if (mem.eql(u8, cpu_name, cpu.name)) {
return cpu;
}
}
return error.UnknownCpuModel;
}
pub fn toElfMachine(arch: Arch) std.elf.EM {
return switch (arch) {
.avr => ._AVR,
.msp430 => ._MSP430,
.arc => ._ARC,
.arm => ._ARM,
.armeb => ._ARM,
.hexagon => ._HEXAGON,
.le32 => ._NONE,
.mips => ._MIPS,
.mipsel => ._MIPS_RS3_LE,
.powerpc, .powerpcle => ._PPC,
.r600 => ._NONE,
.riscv32 => ._RISCV,
.sparc => ._SPARC,
.sparcel => ._SPARC,
.tce => ._NONE,
.tcele => ._NONE,
.thumb => ._ARM,
.thumbeb => ._ARM,
.i386 => ._386,
.xcore => ._XCORE,
.nvptx => ._NONE,
.amdil => ._NONE,
.hsail => ._NONE,
.spir => ._NONE,
.kalimba => ._CSR_KALIMBA,
.shave => ._NONE,
.lanai => ._LANAI,
.wasm32 => ._NONE,
.renderscript32 => ._NONE,
.aarch64_32 => ._AARCH64,
.aarch64 => ._AARCH64,
.aarch64_be => ._AARCH64,
.mips64 => ._MIPS,
.mips64el => ._MIPS_RS3_LE,
.powerpc64 => ._PPC64,
.powerpc64le => ._PPC64,
.riscv64 => ._RISCV,
.x86_64 => ._X86_64,
.nvptx64 => ._NONE,
.le64 => ._NONE,
.amdil64 => ._NONE,
.hsail64 => ._NONE,
.spir64 => ._NONE,
.wasm64 => ._NONE,
.renderscript64 => ._NONE,
.amdgcn => ._NONE,
.bpfel => ._BPF,
.bpfeb => ._BPF,
.csky => ._NONE,
.sparcv9 => ._SPARCV9,
.s390x => ._S390,
.ve => ._NONE,
.spu_2 => ._SPU_2,
.spirv32 => ._NONE,
.spirv64 => ._NONE,
};
}
pub fn toCoffMachine(arch: Arch) std.coff.MachineType {
return switch (arch) {
.avr => .Unknown,
.msp430 => .Unknown,
.arc => .Unknown,
.arm => .ARM,
.armeb => .Unknown,
.hexagon => .Unknown,
.le32 => .Unknown,
.mips => .Unknown,
.mipsel => .Unknown,
.powerpc, .powerpcle => .POWERPC,
.r600 => .Unknown,
.riscv32 => .RISCV32,
.sparc => .Unknown,
.sparcel => .Unknown,
.tce => .Unknown,
.tcele => .Unknown,
.thumb => .Thumb,
.thumbeb => .Thumb,
.i386 => .I386,
.xcore => .Unknown,
.nvptx => .Unknown,
.amdil => .Unknown,
.hsail => .Unknown,
.spir => .Unknown,
.kalimba => .Unknown,
.shave => .Unknown,
.lanai => .Unknown,
.wasm32 => .Unknown,
.renderscript32 => .Unknown,
.aarch64_32 => .ARM64,
.aarch64 => .ARM64,
.aarch64_be => .Unknown,
.mips64 => .Unknown,
.mips64el => .Unknown,
.powerpc64 => .Unknown,
.powerpc64le => .Unknown,
.riscv64 => .RISCV64,
.x86_64 => .X64,
.nvptx64 => .Unknown,
.le64 => .Unknown,
.amdil64 => .Unknown,
.hsail64 => .Unknown,
.spir64 => .Unknown,
.wasm64 => .Unknown,
.renderscript64 => .Unknown,
.amdgcn => .Unknown,
.bpfel => .Unknown,
.bpfeb => .Unknown,
.csky => .Unknown,
.sparcv9 => .Unknown,
.s390x => .Unknown,
.ve => .Unknown,
.spu_2 => .Unknown,
.spirv32 => .Unknown,
.spirv64 => .Unknown,
};
}
pub fn endian(arch: Arch) builtin.Endian {
return switch (arch) {
.avr,
.arm,
.aarch64_32,
.aarch64,
.amdgcn,
.amdil,
.amdil64,
.bpfel,
.csky,
.hexagon,
.hsail,
.hsail64,
.kalimba,
.le32,
.le64,
.mipsel,
.mips64el,
.msp430,
.nvptx,
.nvptx64,
.sparcel,
.tcele,
.powerpcle,
.powerpc64le,
.r600,
.riscv32,
.riscv64,
.i386,
.x86_64,
.wasm32,
.wasm64,
.xcore,
.thumb,
.spir,
.spir64,
.renderscript32,
.renderscript64,
.shave,
.ve,
.spu_2,
// GPU bitness is opaque. For now, assume little endian.
.spirv32,
.spirv64,
=> .Little,
.arc,
.armeb,
.aarch64_be,
.bpfeb,
.mips,
.mips64,
.powerpc,
.powerpc64,
.thumbeb,
.sparc,
.sparcv9,
.tce,
.lanai,
.s390x,
=> .Big,
};
}
pub fn ptrBitWidth(arch: Arch) u16 {
switch (arch) {
.avr,
.msp430,
.spu_2,
=> return 16,
.arc,
.arm,
.armeb,
.csky,
.hexagon,
.le32,
.mips,
.mipsel,
.powerpc,
.powerpcle,
.r600,
.riscv32,
.sparc,
.sparcel,
.tce,
.tcele,
.thumb,
.thumbeb,
.i386,
.xcore,
.nvptx,
.amdil,
.hsail,
.spir,
.kalimba,
.shave,
.lanai,
.wasm32,
.renderscript32,
.aarch64_32,
.spirv32,
=> return 32,
.aarch64,
.aarch64_be,
.mips64,
.mips64el,
.powerpc64,
.powerpc64le,
.riscv64,
.x86_64,
.nvptx64,
.le64,
.amdil64,
.hsail64,
.spir64,
.wasm64,
.renderscript64,
.amdgcn,
.bpfel,
.bpfeb,
.sparcv9,
.s390x,
.ve,
.spirv64,
=> return 64,
}
}
/// Returns a name that matches the lib/std/target/* source file name.
pub fn genericName(arch: Arch) []const u8 {
return switch (arch) {
.arm, .armeb, .thumb, .thumbeb => "arm",
.aarch64, .aarch64_be, .aarch64_32 => "aarch64",
.bpfel, .bpfeb => "bpf",
.mips, .mipsel, .mips64, .mips64el => "mips",
.powerpc, .powerpcle, .powerpc64, .powerpc64le => "powerpc",
.amdgcn => "amdgpu",
.riscv32, .riscv64 => "riscv",
.sparc, .sparcv9, .sparcel => "sparc",
.s390x => "systemz",
.i386, .x86_64 => "x86",
.nvptx, .nvptx64 => "nvptx",
.wasm32, .wasm64 => "wasm",
.spirv32, .spirv64 => "spir-v",
else => @tagName(arch),
};
}
/// All CPU features Zig is aware of, sorted lexicographically by name.
pub fn allFeaturesList(arch: Arch) []const Cpu.Feature {
return switch (arch) {
.arm, .armeb, .thumb, .thumbeb => &arm.all_features,
.aarch64, .aarch64_be, .aarch64_32 => &aarch64.all_features,
.avr => &avr.all_features,
.bpfel, .bpfeb => &bpf.all_features,
.hexagon => &hexagon.all_features,
.mips, .mipsel, .mips64, .mips64el => &mips.all_features,
.msp430 => &msp430.all_features,
.powerpc, .powerpcle, .powerpc64, .powerpc64le => &powerpc.all_features,
.amdgcn => &amdgpu.all_features,
.riscv32, .riscv64 => &riscv.all_features,
.sparc, .sparcv9, .sparcel => &sparc.all_features,
.spirv32, .spirv64 => &spirv.all_features,
.s390x => &systemz.all_features,
.i386, .x86_64 => &x86.all_features,
.nvptx, .nvptx64 => &nvptx.all_features,
.ve => &ve.all_features,
.wasm32, .wasm64 => &wasm.all_features,
else => &[0]Cpu.Feature{},
};
}
/// All processors Zig is aware of, sorted lexicographically by name.
pub fn allCpuModels(arch: Arch) []const *const Cpu.Model {
return switch (arch) {
.arm, .armeb, .thumb, .thumbeb => comptime allCpusFromDecls(arm.cpu),
.aarch64, .aarch64_be, .aarch64_32 => comptime allCpusFromDecls(aarch64.cpu),
.avr => comptime allCpusFromDecls(avr.cpu),
.bpfel, .bpfeb => comptime allCpusFromDecls(bpf.cpu),
.hexagon => comptime allCpusFromDecls(hexagon.cpu),
.mips, .mipsel, .mips64, .mips64el => comptime allCpusFromDecls(mips.cpu),
.msp430 => comptime allCpusFromDecls(msp430.cpu),
.powerpc, .powerpcle, .powerpc64, .powerpc64le => comptime allCpusFromDecls(powerpc.cpu),
.amdgcn => comptime allCpusFromDecls(amdgpu.cpu),
.riscv32, .riscv64 => comptime allCpusFromDecls(riscv.cpu),
.sparc, .sparcv9, .sparcel => comptime allCpusFromDecls(sparc.cpu),
.s390x => comptime allCpusFromDecls(systemz.cpu),
.i386, .x86_64 => comptime allCpusFromDecls(x86.cpu),
.nvptx, .nvptx64 => comptime allCpusFromDecls(nvptx.cpu),
.ve => comptime allCpusFromDecls(ve.cpu),
.wasm32, .wasm64 => comptime allCpusFromDecls(wasm.cpu),
else => &[0]*const Model{},
};
}
fn allCpusFromDecls(comptime cpus: type) []const *const Cpu.Model {
const decls = std.meta.declarations(cpus);
var array: [decls.len]*const Cpu.Model = undefined;
for (decls) |decl, i| {
array[i] = &@field(cpus, decl.name);
}
return &array;
}
};
pub const Model = struct {
name: []const u8,
llvm_name: ?[:0]const u8,
features: Feature.Set,
pub fn toCpu(model: *const Model, arch: Arch) Cpu {
var features = model.features;
features.populateDependencies(arch.allFeaturesList());
return .{
.arch = arch,
.model = model,
.features = features,
};
}
pub fn generic(arch: Arch) *const Model {
const S = struct {
const generic_model = Model{
.name = "generic",
.llvm_name = null,
.features = Cpu.Feature.Set.empty,
};
};
return switch (arch) {
.arm, .armeb, .thumb, .thumbeb => &arm.cpu.generic,
.aarch64, .aarch64_be, .aarch64_32 => &aarch64.cpu.generic,
.avr => &avr.cpu.avr2,
.bpfel, .bpfeb => &bpf.cpu.generic,
.hexagon => &hexagon.cpu.generic,
.mips, .mipsel => &mips.cpu.mips32,
.mips64, .mips64el => &mips.cpu.mips64,
.msp430 => &msp430.cpu.generic,
.powerpc => &powerpc.cpu.ppc,
.powerpcle => &powerpc.cpu.ppc,
.powerpc64 => &powerpc.cpu.ppc64,
.powerpc64le => &powerpc.cpu.ppc64le,
.amdgcn => &amdgpu.cpu.generic,
.riscv32 => &riscv.cpu.generic_rv32,
.riscv64 => &riscv.cpu.generic_rv64,
.sparc, .sparcel => &sparc.cpu.generic,
.sparcv9 => &sparc.cpu.v9,
.s390x => &systemz.cpu.generic,
.i386 => &x86.cpu._i386,
.x86_64 => &x86.cpu.x86_64,
.nvptx, .nvptx64 => &nvptx.cpu.sm_20,
.ve => &ve.cpu.generic,
.wasm32, .wasm64 => &wasm.cpu.generic,
else => &S.generic_model,
};
}
pub fn baseline(arch: Arch) *const Model {
return switch (arch) {
.arm, .armeb, .thumb, .thumbeb => &arm.cpu.baseline,
.riscv32 => &riscv.cpu.baseline_rv32,
.riscv64 => &riscv.cpu.baseline_rv64,
.i386 => &x86.cpu.pentium4,
.nvptx, .nvptx64 => &nvptx.cpu.sm_20,
.sparc, .sparcel => &sparc.cpu.v8,
else => generic(arch),
};
}
};
/// The "default" set of CPU features for cross-compiling. A conservative set
/// of features that is expected to be supported on most available hardware.
pub fn baseline(arch: Arch) Cpu {
return Model.baseline(arch).toCpu(arch);
}
};
pub const current = builtin.target;
pub const stack_align = 16;
pub fn zigTriple(self: Target, allocator: *mem.Allocator) ![]u8 {
return std.zig.CrossTarget.fromTarget(self).zigTriple(allocator);
}
pub fn linuxTripleSimple(allocator: *mem.Allocator, cpu_arch: Cpu.Arch, os_tag: Os.Tag, abi: Abi) ![]u8 {
return std.fmt.allocPrint(allocator, "{s}-{s}-{s}", .{ @tagName(cpu_arch), @tagName(os_tag), @tagName(abi) });
}
pub fn linuxTriple(self: Target, allocator: *mem.Allocator) ![]u8 {
return linuxTripleSimple(allocator, self.cpu.arch, self.os.tag, self.abi);
}
pub fn oFileExt_os_abi(os_tag: Os.Tag, abi: Abi) [:0]const u8 {
if (abi == .msvc) {
return ".obj";
}
switch (os_tag) {
.windows, .uefi => return ".obj",
else => return ".o",
}
}
pub fn oFileExt(self: Target) [:0]const u8 {
return oFileExt_os_abi(self.os.tag, self.abi);
}
pub fn exeFileExtSimple(cpu_arch: Cpu.Arch, os_tag: Os.Tag) [:0]const u8 {
switch (os_tag) {
.windows => return ".exe",
.uefi => return ".efi",
else => if (cpu_arch.isWasm()) {
return ".wasm";
} else {
return "";
},
}
}
pub fn exeFileExt(self: Target) [:0]const u8 {
return exeFileExtSimple(self.cpu.arch, self.os.tag);
}
pub fn staticLibSuffix_os_abi(os_tag: Os.Tag, abi: Abi) [:0]const u8 {
if (abi == .msvc) {
return ".lib";
}
switch (os_tag) {
.windows, .uefi => return ".lib",
else => return ".a",
}
}
pub fn staticLibSuffix(self: Target) [:0]const u8 {
return staticLibSuffix_os_abi(self.os.tag, self.abi);
}
pub fn dynamicLibSuffix(self: Target) [:0]const u8 {
return self.os.tag.dynamicLibSuffix();
}
pub fn libPrefix_os_abi(os_tag: Os.Tag, abi: Abi) [:0]const u8 {
if (abi == .msvc) {
return "";
}
switch (os_tag) {
.windows, .uefi => return "",
else => return "lib",
}
}
pub fn libPrefix(self: Target) [:0]const u8 {
return libPrefix_os_abi(self.os.tag, self.abi);
}
pub fn getObjectFormatSimple(os_tag: Os.Tag, cpu_arch: Cpu.Arch) ObjectFormat {
if (os_tag == .windows or os_tag == .uefi) {
return .coff;
} else if (os_tag.isDarwin()) {
return .macho;
}
if (cpu_arch.isWasm()) {
return .wasm;
}
if (cpu_arch.isSPIRV()) {
return .spirv;
}
return .elf;
}
pub fn getObjectFormat(self: Target) ObjectFormat {
return getObjectFormatSimple(self.os.tag, self.cpu.arch);
}
pub fn isMinGW(self: Target) bool {
return self.os.tag == .windows and self.isGnu();
}
pub fn isGnu(self: Target) bool {
return self.abi.isGnu();
}
pub fn isMusl(self: Target) bool {
return self.abi.isMusl();
}
pub fn isAndroid(self: Target) bool {
return switch (self.abi) {
.android => true,
else => false,
};
}
pub fn isWasm(self: Target) bool {
return self.cpu.arch.isWasm();
}
pub fn isDarwin(self: Target) bool {
return self.os.tag.isDarwin();
}
pub fn isGnuLibC_os_tag_abi(os_tag: Os.Tag, abi: Abi) bool {
return os_tag == .linux and abi.isGnu();
}
pub fn isGnuLibC(self: Target) bool {
return isGnuLibC_os_tag_abi(self.os.tag, self.abi);
}
pub fn supportsNewStackCall(self: Target) bool {
return !self.cpu.arch.isWasm();
}
pub const FloatAbi = enum {
hard,
soft,
soft_fp,
};
pub fn getFloatAbi(self: Target) FloatAbi {
return self.abi.floatAbi();
}
pub fn hasDynamicLinker(self: Target) bool {
if (self.cpu.arch.isWasm()) {
return false;
}
switch (self.os.tag) {
.freestanding,
.ios,
.tvos,
.watchos,
.macos,
.uefi,
.windows,
.emscripten,
.opencl,
.glsl450,
.vulkan,
.other,
=> return false,
else => return true,
}
}
pub const DynamicLinker = struct {
/// Contains the memory used to store the dynamic linker path. This field should
/// not be used directly. See `get` and `set`. This field exists so that this API requires no allocator.
buffer: [255]u8 = undefined,
/// Used to construct the dynamic linker path. This field should not be used
/// directly. See `get` and `set`.
max_byte: ?u8 = null,
/// Asserts that the length is less than or equal to 255 bytes.
pub fn init(dl_or_null: ?[]const u8) DynamicLinker {
var result: DynamicLinker = undefined;
result.set(dl_or_null);
return result;
}
/// The returned memory has the same lifetime as the `DynamicLinker`.
pub fn get(self: *const DynamicLinker) ?[]const u8 {
const m: usize = self.max_byte orelse return null;
return self.buffer[0 .. m + 1];
}
/// Asserts that the length is less than or equal to 255 bytes.
pub fn set(self: *DynamicLinker, dl_or_null: ?[]const u8) void {
if (dl_or_null) |dl| {
mem.copy(u8, &self.buffer, dl);
self.max_byte = @intCast(u8, dl.len - 1);
} else {
self.max_byte = null;
}
}
};
pub fn standardDynamicLinkerPath(self: Target) DynamicLinker {
var result: DynamicLinker = .{};
const S = struct {
fn print(r: *DynamicLinker, comptime fmt: []const u8, args: anytype) DynamicLinker {
r.max_byte = @intCast(u8, (std.fmt.bufPrint(&r.buffer, fmt, args) catch unreachable).len - 1);
return r.*;
}
fn copy(r: *DynamicLinker, s: []const u8) DynamicLinker {
mem.copy(u8, &r.buffer, s);
r.max_byte = @intCast(u8, s.len - 1);
return r.*;
}
};
const print = S.print;
const copy = S.copy;
if (self.abi == .android) {
const suffix = if (self.cpu.arch.ptrBitWidth() == 64) "64" else "";
return print(&result, "/system/bin/linker{s}", .{suffix});
}
if (self.abi.isMusl()) {
const is_arm = switch (self.cpu.arch) {
.arm, .armeb, .thumb, .thumbeb => true,
else => false,
};
const arch_part = switch (self.cpu.arch) {
.arm, .thumb => "arm",
.armeb, .thumbeb => "armeb",
else => |arch| @tagName(arch),
};
const arch_suffix = if (is_arm and self.abi.floatAbi() == .hard) "hf" else "";
return print(&result, "/lib/ld-musl-{s}{s}.so.1", .{ arch_part, arch_suffix });
}
switch (self.os.tag) {
.freebsd => return copy(&result, "/libexec/ld-elf.so.1"),
.netbsd => return copy(&result, "/libexec/ld.elf_so"),
.openbsd => return copy(&result, "/usr/libexec/ld.so"),
.dragonfly => return copy(&result, "/libexec/ld-elf.so.2"),
.linux => switch (self.cpu.arch) {
.i386,
.sparc,
.sparcel,
=> return copy(&result, "/lib/ld-linux.so.2"),
.aarch64 => return copy(&result, "/lib/ld-linux-aarch64.so.1"),
.aarch64_be => return copy(&result, "/lib/ld-linux-aarch64_be.so.1"),
.aarch64_32 => return copy(&result, "/lib/ld-linux-aarch64_32.so.1"),
.arm,
.armeb,
.thumb,
.thumbeb,
=> return copy(&result, switch (self.abi.floatAbi()) {
.hard => "/lib/ld-linux-armhf.so.3",
else => "/lib/ld-linux.so.3",
}),
.mips,
.mipsel,
.mips64,
.mips64el,
=> {
const lib_suffix = switch (self.abi) {
.gnuabin32, .gnux32 => "32",
.gnuabi64 => "64",
else => "",
};
const is_nan_2008 = mips.featureSetHas(self.cpu.features, .nan2008);
const loader = if (is_nan_2008) "ld-linux-mipsn8.so.1" else "ld.so.1";
return print(&result, "/lib{s}/{s}", .{ lib_suffix, loader });
},
.powerpc, .powerpcle => return copy(&result, "/lib/ld.so.1"),
.powerpc64, .powerpc64le => return copy(&result, "/lib64/ld64.so.2"),
.s390x => return copy(&result, "/lib64/ld64.so.1"),
.sparcv9 => return copy(&result, "/lib64/ld-linux.so.2"),
.x86_64 => return copy(&result, switch (self.abi) {
.gnux32 => "/libx32/ld-linux-x32.so.2",
else => "/lib64/ld-linux-x86-64.so.2",
}),
.riscv32 => return copy(&result, "/lib/ld-linux-riscv32-ilp32.so.1"),
.riscv64 => return copy(&result, "/lib/ld-linux-riscv64-lp64.so.1"),
// Architectures in this list have been verified as not having a standard
// dynamic linker path.
.wasm32,
.wasm64,
.bpfel,
.bpfeb,
.nvptx,
.nvptx64,
.spu_2,
.avr,
.spirv32,
.spirv64,
=> return result,
// TODO go over each item in this list and either move it to the above list, or
// implement the standard dynamic linker path code for it.
.arc,
.csky,
.hexagon,
.msp430,
.r600,
.amdgcn,
.tce,
.tcele,
.xcore,
.le32,
.le64,
.amdil,
.amdil64,
.hsail,
.hsail64,
.spir,
.spir64,
.kalimba,
.shave,
.lanai,
.renderscript32,
.renderscript64,
.ve,
=> return result,
},
.ios,
.tvos,
.watchos,
.macos,
=> return copy(&result, "/usr/lib/dyld"),
// Operating systems in this list have been verified as not having a standard
// dynamic linker path.
.freestanding,
.uefi,
.windows,
.emscripten,
.wasi,
.opencl,
.glsl450,
.vulkan,
.other,
=> return result,
// TODO revisit when multi-arch for Haiku is available
.haiku => return copy(&result, "/system/runtime_loader"),
// TODO go over each item in this list and either move it to the above list, or
// implement the standard dynamic linker path code for it.
.ananas,
.cloudabi,
.fuchsia,
.kfreebsd,
.lv2,
.solaris,
.zos,
.minix,
.rtems,
.nacl,
.aix,
.cuda,
.nvcl,
.amdhsa,
.ps4,
.elfiamcu,
.mesa3d,
.contiki,
.amdpal,
.hermit,
.hurd,
=> return result,
}
}
/// Return whether or not the given host target is capable of executing natively executables
/// of the other target.
pub fn canExecBinariesOf(host_target: Target, binary_target: Target) bool {
if (host_target.os.tag != binary_target.os.tag)
return false;
if (host_target.cpu.arch == binary_target.cpu.arch)
return true;
if (host_target.cpu.arch == .x86_64 and binary_target.cpu.arch == .i386)
return true;
if (host_target.cpu.arch == .aarch64 and binary_target.cpu.arch == .arm)
return true;
if (host_target.cpu.arch == .aarch64_be and binary_target.cpu.arch == .armeb)
return true;
return false;
}
};
test {
std.testing.refAllDecls(Target.Cpu.Arch);
}
| 35.132406 | 135 | 0.42305 |
0fb1cbe5a719988585d97d45f23d56395af95220 | 4,217 | zig | Zig | 2021/day04.zig | jonase/advent-of-code | 3f341925bf5c53709ba3a814d2980c7a1383515b | [
"MIT"
] | null | null | null | 2021/day04.zig | jonase/advent-of-code | 3f341925bf5c53709ba3a814d2980c7a1383515b | [
"MIT"
] | null | null | null | 2021/day04.zig | jonase/advent-of-code | 3f341925bf5c53709ba3a814d2980c7a1383515b | [
"MIT"
] | null | null | null | const std = @import("std");
const input = @embedFile("day04.txt");
const Board = struct {
grid: [5][5]u8,
marked: u25,
};
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
const allocator = &gpa.allocator;
var iter = std.mem.split(u8, input, "\n\n");
const nums: []u8 = result: {
var list = std.ArrayList(u8).init(allocator);
var nums_iter = std.mem.split(u8, iter.next().?, ",");
while (nums_iter.next()) |num_str| {
try list.append(try std.fmt.parseInt(u8, num_str, 10));
}
break :result list.toOwnedSlice();
};
defer allocator.free(nums);
const boards: []Board = result: {
var list = std.ArrayList(Board).init(allocator);
while (iter.next()) |board_str| {
var board: Board = undefined;
try parseBoard(board_str, &board);
try list.append(board);
}
break :result list.toOwnedSlice();
};
defer allocator.free(boards);
var bingo_count: u32 = 0;
var first_found_board: Board = undefined;
var first_found_num: u8 = undefined;
var last_found_board: Board = undefined;
var last_found_num: u8 = undefined;
for (nums) |num| {
for (boards) |*board| {
if (isBingo(board.marked)) continue;
markNum(board, num);
if (isBingo(board.marked)) {
bingo_count += 1;
if (bingo_count == 1) {
first_found_board = board.*;
first_found_num = num;
}
if (bingo_count == boards.len) {
last_found_board = board.*;
last_found_num = num;
}
}
}
}
std.debug.print("Part 1: {d}\n", .{countUnmarked(first_found_board) * first_found_num});
std.debug.print("Part 2: {d}\n", .{countUnmarked(last_found_board) * last_found_num});
}
fn parseBoard(board_str: []const u8, board: *Board) !void {
var rows = std.mem.split(u8, board_str, "\n");
var row_idx: usize = 0;
while (rows.next()) |row_str| : (row_idx += 1) {
var cols = std.mem.tokenize(u8, row_str, " ");
var col_idx: usize = 0;
while (cols.next()) |col_str| : (col_idx += 1) {
const n = try std.fmt.parseInt(u8, col_str, 10);
board.grid[row_idx][col_idx] = n;
}
}
board.marked = 0;
}
fn printBoard(board: Board) void {
for (board.grid) |row, row_idx| {
for (row) |n, col_idx| {
if (isMarked(board.marked, row_idx, col_idx)) {
std.debug.print("\x1b[41;1m{d:2}\x1b[0m ", .{n});
} else {
std.debug.print("{d:2} ", .{n});
}
}
std.debug.print("\n", .{});
}
}
fn isMarked(marked: u25, row_idx: usize, col_idx: usize) bool {
var nbit = row_idx * 5 + col_idx;
return marked & @as(u25, 1) << @intCast(u5, nbit) != 0;
}
fn markNum(board: *Board, num: u8) void {
for (board.grid) |row, row_idx| {
for (row) |n, col_idx| {
if (n == num) {
mark(&board.marked, row_idx, col_idx);
}
}
}
}
fn mark(marked: *u25, row_idx: usize, col_idx: usize) void {
var nbit = row_idx * 5 + col_idx;
marked.* |= @as(u25, 1) << @intCast(u5, nbit);
}
const bingo_patterns = [_]u25{
0b11111_00000_00000_00000_00000,
0b00000_11111_00000_00000_00000,
0b00000_00000_11111_00000_00000,
0b00000_00000_00000_11111_00000,
0b00000_00000_00000_00000_11111,
0b10000_10000_10000_10000_10000,
0b01000_01000_01000_01000_01000,
0b00100_00100_00100_00100_00100,
0b00010_00010_00010_00010_00010,
0b00001_00001_00001_00001_00001,
};
fn isBingo(marked: u25) bool {
for (bingo_patterns) |bingo_pattern| {
if (marked & bingo_pattern == bingo_pattern) return true;
}
return false;
}
fn countUnmarked(board: Board) u32 {
var unmarked_sum: u32 = 0;
for (board.grid) |row, row_idx| {
for (row) |n, col_idx| {
if (!isMarked(board.marked, row_idx, col_idx)) {
unmarked_sum += n;
}
}
}
return unmarked_sum;
}
| 29.697183 | 92 | 0.559165 |
533ac928b462fd50467af59cd2a7f7ffe542c686 | 302 | zig | Zig | test/compile_errors/stage1/obj/issue_7810-comptime_slice-len_increment_beyond_bounds.zig | damienfir/zig | 1a1b5ee264d8b2219c34d53cc9602692e6d2ba24 | [
"MIT"
] | null | null | null | test/compile_errors/stage1/obj/issue_7810-comptime_slice-len_increment_beyond_bounds.zig | damienfir/zig | 1a1b5ee264d8b2219c34d53cc9602692e6d2ba24 | [
"MIT"
] | null | null | null | test/compile_errors/stage1/obj/issue_7810-comptime_slice-len_increment_beyond_bounds.zig | damienfir/zig | 1a1b5ee264d8b2219c34d53cc9602692e6d2ba24 | [
"MIT"
] | null | null | null | export fn foo_slice_len_increment_beyond_bounds() void {
comptime {
var buf_storage: [8]u8 = undefined;
var buf: []const u8 = buf_storage[0..];
buf.len += 1;
buf[8] = 42;
}
}
// comptime slice-len increment beyond bounds
//
// :6:12: error: out of bounds slice
| 23.230769 | 56 | 0.602649 |
283e798cc5ae3825a8fc3f36c5ba1811ec9b2cea | 334 | zig | Zig | src/drivers/drivers.zig | aurelian2/Florence | 4869f92957b27ebf57687189cb08c52cacdd0c12 | [
"CC0-1.0"
] | 2 | 2021-05-15T09:16:47.000Z | 2021-05-15T16:08:32.000Z | src/drivers/drivers.zig | aurelian2/Florence | 4869f92957b27ebf57687189cb08c52cacdd0c12 | [
"CC0-1.0"
] | null | null | null | src/drivers/drivers.zig | aurelian2/Florence | 4869f92957b27ebf57687189cb08c52cacdd0c12 | [
"CC0-1.0"
] | null | null | null | pub const mmio_serial = @import("io/mmio_serial.zig");
pub const vesa_log = @import("io/vesa_log.zig");
pub const vga_log = @import("io/vga_log.zig");
pub const ahci = @import("disk/ahci.zig");
pub const virtio_gpu = @import("virtio/virtio-gpu.zig");
pub const hid = .{
.keyboard = @import("hid/keyboard.zig"),
};
| 27.833333 | 57 | 0.655689 |
897d568d95208abe569450ce7880c8dc73ee12f7 | 41 | zig | Zig | src/lang/ast/encoding.zig | clpi/idl | 368f517785c917e280372126905571622ec0a995 | [
"MIT"
] | 1 | 2022-01-03T13:35:27.000Z | 2022-01-03T13:35:27.000Z | src/lang/ast/encoding.zig | clpi/idl | 368f517785c917e280372126905571622ec0a995 | [
"MIT"
] | null | null | null | src/lang/ast/encoding.zig | clpi/idl | 368f517785c917e280372126905571622ec0a995 | [
"MIT"
] | null | null | null | pub const typecoe = union(enum) {
}
| 10.25 | 33 | 0.585366 |
46c1df03bb08c6edcde19578c32613f1d66dfdf4 | 178 | zig | Zig | src/math/vec2.zig | Black-Cat/nyancore | ddb57a25b68c77dd46c8b5f36fbb6a4d843534d0 | [
"MIT"
] | null | null | null | src/math/vec2.zig | Black-Cat/nyancore | ddb57a25b68c77dd46c8b5f36fbb6a4d843534d0 | [
"MIT"
] | null | null | null | src/math/vec2.zig | Black-Cat/nyancore | ddb57a25b68c77dd46c8b5f36fbb6a4d843534d0 | [
"MIT"
] | null | null | null | const math = @import("math.zig");
pub fn dot(a: math.vec2, b: math.vec2) f32 {
return a[0] * b[0] + a[1] * b[1];
}
pub fn norm2(a: math.vec2) f32 {
return dot(a, a);
}
| 17.8 | 44 | 0.550562 |
82e46e5b6f581863d5a22005788b72fa8077ed12 | 56 | zpl | Zimpl | lib/scipoptsuite-5.0.1/zimpl/check/errors/e168.zpl | npwebste/UPS_Controller | a90ce2229108197fd48f956310ae2929e0fa5d9a | [
"AFL-1.1"
] | null | null | null | lib/scipoptsuite-5.0.1/zimpl/check/errors/e168.zpl | npwebste/UPS_Controller | a90ce2229108197fd48f956310ae2929e0fa5d9a | [
"AFL-1.1"
] | null | null | null | lib/scipoptsuite-5.0.1/zimpl/check/errors/e168.zpl | npwebste/UPS_Controller | a90ce2229108197fd48f956310ae2929e0fa5d9a | [
"AFL-1.1"
] | 1 | 2022-01-19T01:15:11.000Z | 2022-01-19T01:15:11.000Z | # $Id: e168.zpl,v 1.5 2010/06/10 19:42:41 bzfkocht Exp $ | 56 | 56 | 0.660714 |
3d6ffde48ddde0473256ba8b66c481525af9e4e6 | 96 | zpl | Zimpl | lib/scipoptsuite-5.0.1/zimpl/check/errors/e119_4.zpl | npwebste/UPS_Controller | a90ce2229108197fd48f956310ae2929e0fa5d9a | [
"AFL-1.1"
] | null | null | null | lib/scipoptsuite-5.0.1/zimpl/check/errors/e119_4.zpl | npwebste/UPS_Controller | a90ce2229108197fd48f956310ae2929e0fa5d9a | [
"AFL-1.1"
] | null | null | null | lib/scipoptsuite-5.0.1/zimpl/check/errors/e119_4.zpl | npwebste/UPS_Controller | a90ce2229108197fd48f956310ae2929e0fa5d9a | [
"AFL-1.1"
] | 1 | 2022-01-19T01:15:11.000Z | 2022-01-19T01:15:11.000Z | # $Id: e119_4.zpl,v 1.5 2010/06/10 19:42:41 bzfkocht Exp $
set A:={1..5} symdiff {1..2}*{3..4};
| 32 | 58 | 0.583333 |
d35c7f06a7484abaf7a0d19591ec349e54174622 | 262 | desktop | desktop | applications/xdg-gmail.desktop | mbr/binbin | 39fbdfd60d5165117ce9bcc8cb24b2293322db49 | [
"MIT"
] | 4 | 2016-09-09T10:32:05.000Z | 2021-12-25T16:05:12.000Z | applications/xdg-gmail.desktop | mbr/binbin | 39fbdfd60d5165117ce9bcc8cb24b2293322db49 | [
"MIT"
] | null | null | null | applications/xdg-gmail.desktop | mbr/binbin | 39fbdfd60d5165117ce9bcc8cb24b2293322db49 | [
"MIT"
] | null | null | null | [Desktop Entry]
Version=1.0
Name=GoogleMail
GenericName=Email
Comment=Send and Receive Email
Exec=xdg-gmail chromium %u
Icon=gmail.png
Terminal=false
Type=Application
MimeType=message/rfc822;x-scheme-handler/mailto;
StartupNotify=false
Categories=Network;Email;
| 20.153846 | 48 | 0.835878 |
611abfa22c665957f5d916f40e13f5913b287746 | 122 | desktop | desktop | dotfiles/.config/autostart/conky.desktop | Toxblh/Linux-Applications | 55598eb182171bd9e93b7a4a162aa76aa02f4cf0 | [
"MIT"
] | 8 | 2019-09-03T13:11:17.000Z | 2022-01-21T10:18:53.000Z | dotfiles/.config/autostart/conky.desktop | Toxblh/Linux-Applications | 55598eb182171bd9e93b7a4a162aa76aa02f4cf0 | [
"MIT"
] | null | null | null | dotfiles/.config/autostart/conky.desktop | Toxblh/Linux-Applications | 55598eb182171bd9e93b7a4a162aa76aa02f4cf0 | [
"MIT"
] | 1 | 2021-09-06T15:53:19.000Z | 2021-09-06T15:53:19.000Z | [Desktop Entry]
Type=Application
Name=Conky
Exec=/home/toxblh/.config/conky/startup.sh
Terminal=false
StartupNotify=false
| 17.428571 | 42 | 0.827869 |
0210819900d6b9f349b99ce854a177b6ec40e2dc | 233 | desktop | desktop | freebsd/loader.conf.desktop | christosmarg/dotfiles | 6d49fe2bd6a66726138b414d6e33363b4ab00885 | [
"MIT"
] | null | null | null | freebsd/loader.conf.desktop | christosmarg/dotfiles | 6d49fe2bd6a66726138b414d6e33363b4ab00885 | [
"MIT"
] | null | null | null | freebsd/loader.conf.desktop | christosmarg/dotfiles | 6d49fe2bd6a66726138b414d6e33363b4ab00885 | [
"MIT"
] | null | null | null | kern.vty="YES"
kern.geom.label.disk_ident.enable="0"
kern.geom.label.gptid.enable="0"
kern.geom.label.ufsid.enable="0"
zfs_load="YES"
nvidia_name="nvidia"
nvidia_modeset_load="YES"
nvidia_modeset_name="nvidia-modeset"
vmm_load="YES"
| 23.3 | 37 | 0.785408 |
f99a8433813ea0edd824d40340905f3f74236696 | 559 | desktop | desktop | database/quokkagit/org.ballessay.quokkagit.desktop | Swiftapp-hub/appimage.github.io | 751131fab7beffc11bee43c56bea1760190061e3 | [
"MIT"
] | 228 | 2017-08-23T13:35:04.000Z | 2022-03-30T20:57:21.000Z | database/quokkagit/org.ballessay.quokkagit.desktop | Swiftapp-hub/appimage.github.io | 751131fab7beffc11bee43c56bea1760190061e3 | [
"MIT"
] | 1,504 | 2017-08-21T15:06:59.000Z | 2022-03-31T20:22:42.000Z | database/quokkagit/org.ballessay.quokkagit.desktop | Swiftapp-hub/appimage.github.io | 751131fab7beffc11bee43c56bea1760190061e3 | [
"MIT"
] | 530 | 2017-08-23T13:28:42.000Z | 2022-03-31T20:03:25.000Z | [Desktop Entry]
Type=Application
Comment=A git log viewer
Name=quokkagit
Exec=quokkagit
Icon=quokkagit
Categories=Development;
X-AppImage-Version=61454e8
[AppImageHub]
X-AppImage-UpdateInformation=gh-releases-zsync|ballessay|quokkagit|continuous|quokkagit*-x86_64.AppImage.zsync
X-AppImage-Signature=no valid OpenPGP data found. the signature could not be verified. Please remember that the signature file (.sig or .asc) should be the first file given on the command line.
X-AppImage-Type=2
X-AppImage-Architecture=x86_64
X-AppImage-Payload-License=GPL-3.0
| 34.9375 | 194 | 0.824687 |
5efdb3365fd530ed087ce058dfcab7834acbd04a | 207 | desktop | desktop | configs/host_agnostic/.config/autostart/signal-desktop.desktop | butla/machine_setups | 53c68a7eab25d486d639e97cc1166625f772354b | [
"MIT"
] | 2 | 2021-09-25T01:25:00.000Z | 2021-11-28T21:26:42.000Z | configs/host_agnostic/.config/autostart/signal-desktop.desktop | butla/machine_setups | 53c68a7eab25d486d639e97cc1166625f772354b | [
"MIT"
] | null | null | null | configs/host_agnostic/.config/autostart/signal-desktop.desktop | butla/machine_setups | 53c68a7eab25d486d639e97cc1166625f772354b | [
"MIT"
] | null | null | null | [Desktop Entry]
Encoding=UTF-8
Version=0.9.4
Type=Application
Name=signal-desktop
Comment=private communicator
Exec=signal-desktop
OnlyShowIn=XFCE;
RunHook=0
StartupNotify=false
Terminal=false
Hidden=false
| 14.785714 | 28 | 0.835749 |
53d987bb710d541061022b5169da5f0cbf50ea12 | 168 | desktop | desktop | cylinder.desktop | Sturmflut/ubuntu-touch-qt3d-cylinder | 0aa6ff7d5b6d06138650fe43a45e764962f3b1bc | [
"BSD-3-Clause"
] | 2 | 2016-09-25T16:21:56.000Z | 2017-10-27T13:28:03.000Z | cylinder.desktop | Sturmflut/ubuntu-touch-qt3d-cylinder | 0aa6ff7d5b6d06138650fe43a45e764962f3b1bc | [
"BSD-3-Clause"
] | 1 | 2016-09-25T16:56:12.000Z | 2017-02-18T23:32:18.000Z | cylinder.desktop | Sturmflut/ubuntu-touch-qt3d-cylinder | 0aa6ff7d5b6d06138650fe43a45e764962f3b1bc | [
"BSD-3-Clause"
] | null | null | null | [Desktop Entry]
Name=Qt3D cylinder
Comment=Qt3D demo app, shows a textured cylinder
Exec=cylinder
Icon=cylinder.png
Terminal=false
Type=Application
X-Ubuntu-Touch=true
| 18.666667 | 48 | 0.827381 |
759f018d17b1bab019447a9dbe11b5e007053cd9 | 235 | desktop | desktop | semana_06/links/In Depth: Principal Component Analysis | Python Data Science Handbook.desktop | alexaldr/AceleraDev-Data-Science | fbb15e59d0299f7103cb1ecfb4de0052022aa111 | [
"MIT"
] | 3 | 2020-04-15T23:15:19.000Z | 2020-04-17T21:18:20.000Z | semana_06/links/In Depth: Principal Component Analysis | Python Data Science Handbook.desktop | alexaldr/AceleraDev-Data-Science | fbb15e59d0299f7103cb1ecfb4de0052022aa111 | [
"MIT"
] | 2 | 2021-02-02T22:40:03.000Z | 2021-08-23T20:42:48.000Z | semana_06/links/In Depth: Principal Component Analysis | Python Data Science Handbook.desktop | alexaldr/AceleraDev-Data-Science | fbb15e59d0299f7103cb1ecfb4de0052022aa111 | [
"MIT"
] | 1 | 2020-04-17T21:18:22.000Z | 2020-04-17T21:18:22.000Z | [Desktop Entry]
Encoding=UTF-8
Name=Link to In Depth: Principal Component Analysis | Python Data Science Handbook
Type=Link
URL=https://jakevdp.github.io/PythonDataScienceHandbook/05.09-principal-component-analysis.html
Icon=text-html
| 33.571429 | 95 | 0.825532 |
4a4fa5e2c9729416494e6ec1e6b506d6a9d9857b | 238 | desktop | desktop | semana_02/links/Pandas Tutorial: Essentials of Data Science in Pandas Library.desktop | alexaldr/AceleraDev-Data-Science | fbb15e59d0299f7103cb1ecfb4de0052022aa111 | [
"MIT"
] | 3 | 2020-04-15T23:15:19.000Z | 2020-04-17T21:18:20.000Z | semana_02/links/Pandas Tutorial: Essentials of Data Science in Pandas Library.desktop | alexaldr/AceleraDev-Data-Science | fbb15e59d0299f7103cb1ecfb4de0052022aa111 | [
"MIT"
] | 2 | 2021-02-02T22:40:03.000Z | 2021-08-23T20:42:48.000Z | semana_02/links/Pandas Tutorial: Essentials of Data Science in Pandas Library.desktop | alexaldr/AceleraDev-Data-Science | fbb15e59d0299f7103cb1ecfb4de0052022aa111 | [
"MIT"
] | 1 | 2020-04-17T21:18:22.000Z | 2020-04-17T21:18:22.000Z | [Desktop Entry]
Encoding=UTF-8
Name=Link to Pandas Tutorial: Essentials of Data Science in Pandas Library
Type=Link
URL=https://medium.com/@shakasom/pandas-tutorial-essentials-of-data-science-in-pandas-library-9b0c81dbfcb1
Icon=text-html
| 34 | 106 | 0.819328 |
be8298782fc8f0921750b60d3d625a702aec820d | 277 | desktop | desktop | config/.config/autostart/ProtonMail Bridge.desktop | jbenden/.dotfiles | e216c932d17dad7b313a51038bed7ba77a458825 | [
"Unlicense"
] | null | null | null | config/.config/autostart/ProtonMail Bridge.desktop | jbenden/.dotfiles | e216c932d17dad7b313a51038bed7ba77a458825 | [
"Unlicense"
] | 2 | 2021-05-23T18:52:49.000Z | 2021-07-05T05:43:03.000Z | config/.config/autostart/ProtonMail Bridge.desktop | jbenden/.dotfiles | e216c932d17dad7b313a51038bed7ba77a458825 | [
"Unlicense"
] | null | null | null | [Desktop Entry]
Type=Application
Name=ProtonMail Bridge
TryExec=/usr/lib/protonmail/bridge/protonmail-bridge
# Exec="/usr/lib/protonmail/bridge/protonmail-bridge.sh" "--no-window"
Exec="/usr/lib/protonmail/bridge/protonmail-bridge" "--no-window"
X-GNOME-Autostart-enabled=true
| 34.625 | 70 | 0.794224 |
6ff4856aed4f25be934367b8a07cf56a2df1f5cd | 128 | desktop | desktop | autostart/emacsd.desktop | pabzdzdzwiagief/dotfiles | c0a35f64dea1bedc4e2ff120061a6aa78b1993d9 | [
"CC0-1.0"
] | 1 | 2017-02-14T05:31:10.000Z | 2017-02-14T05:31:10.000Z | autostart/emacsd.desktop | pabzdzdzwiagief/dotfiles | c0a35f64dea1bedc4e2ff120061a6aa78b1993d9 | [
"CC0-1.0"
] | null | null | null | autostart/emacsd.desktop | pabzdzdzwiagief/dotfiles | c0a35f64dea1bedc4e2ff120061a6aa78b1993d9 | [
"CC0-1.0"
] | null | null | null | [Desktop Entry]
Name=Emacs Daemon
Comment=Start emacs daemon
Exec=emacsd restart
Terminal=false
Type=Application
NoDisplay=true
| 16 | 26 | 0.84375 |
46e24cd971cb054c6e03f864400172eb61e863f2 | 191 | desktop | desktop | recipes/freenote/files/FreeNote/apps/Applications/FreeNote.desktop | JrCs/opendreambox | 9dbb1c7acca49a81082fab043abc4acecb309761 | [
"MIT"
] | 70 | 2015-02-23T04:18:51.000Z | 2022-03-15T02:01:27.000Z | recipes/freenote/files/FreeNote/apps/Applications/FreeNote.desktop | JrCs/opendreambox | 9dbb1c7acca49a81082fab043abc4acecb309761 | [
"MIT"
] | 1 | 2021-11-27T17:24:21.000Z | 2021-11-27T17:24:21.000Z | recipes/freenote/files/FreeNote/apps/Applications/FreeNote.desktop | JrCs/opendreambox | 9dbb1c7acca49a81082fab043abc4acecb309761 | [
"MIT"
] | 88 | 2015-02-11T12:03:16.000Z | 2022-03-30T11:33:42.000Z | [Desktop Entry]
Comment=
Exec=FreeNote
Icon=freenote
Type=Application
Name=FreeNoteQt
Display=640x480/144dpi,480x640/144dpi
MimeType=application/freenote
MimeTypeIcons=freenote
CanFastload=1
| 17.363636 | 37 | 0.863874 |
a002f369dfd3d5c18210f131ad3a6771b0f60476 | 364 | desktop | desktop | electronic-wechat.desktop | ChinaFengliang/electronic-wechat | 8a66c1584bf645dae4e630386abc755554630e9b | [
"MIT"
] | null | null | null | electronic-wechat.desktop | ChinaFengliang/electronic-wechat | 8a66c1584bf645dae4e630386abc755554630e9b | [
"MIT"
] | null | null | null | electronic-wechat.desktop | ChinaFengliang/electronic-wechat | 8a66c1584bf645dae4e630386abc755554630e9b | [
"MIT"
] | null | null | null | [Desktop Entry]
Name=Wechat
Name[zh_CN]=微信电脑版
Name[zh_TW]=微信电脑版
Exec=/home/fengliang/bin/electronic-wechat/dist/electronic-wechat-linux-x64/electronic-wechat
Icon=/home/fengliang/bin/electronic-wechat/assets/Wechat.png
Terminal=false
X-MultipleArgs=false
Type=Application
Encoding=UTF-8
Categories=Application;Utility;Network;InstantMessaging;
StartupNotify=false
| 28 | 93 | 0.846154 |
a506157768c5d8b56bb9c2e15edbb40a18c47d04 | 7,100 | desktop | desktop | afterstep/applications/find.desktop | born2late/afterstep-devel | 0dc407835e84bb75b8c38b07cd222bff41781c10 | [
"MIT"
] | 2 | 2017-06-22T11:45:58.000Z | 2019-02-07T22:14:39.000Z | afterstep/applications/find.desktop | Acidburn0zzz/afterstep-devel | 4f62e0d1f26747924ed6eaad065265640d04ddb0 | [
"MIT"
] | 4 | 2015-04-21T06:04:17.000Z | 2015-09-25T06:25:10.000Z | afterstep/applications/find.desktop | Acidburn0zzz/afterstep-devel | 4f62e0d1f26747924ed6eaad065265640d04ddb0 | [
"MIT"
] | 2 | 2017-07-15T23:27:47.000Z | 2020-01-14T17:43:36.000Z | [Desktop Entry]
Name=GNOME File Search Tool
GenericName=System Search
Comment=Find Files/Folders
Comment[af]=Soek Lêers/Gidse
Comment[bg]=Търсене на файлове
Comment[bn]=ফাইল/ফোল্ডার অনুসন্ধান
Comment[br]=Klask restroù/renkelloù
Comment[bs]=Pronađi datoteke
Comment[ca]=Cerca fitxers i carpetes
Comment[cs]=Najít soubory/složky
Comment[da]=Find filer/mapper
Comment[de]=Dateien/Ordner suchen
Comment[el]=Αναζήτηση αρχείων/φακέλων
Comment[es]=Buscar archivos/carpetas
Comment[et]=Failide/kataloogide otsimine
Comment[eu]=Bilatu fitxategiak/karpetak
Comment[fa]=یافتن پروندهها/پوشهها
Comment[fi]=Etsi tiedostoja ja kansioita
Comment[fr]=Recherche de fichiers/dossiers
Comment[fy]=Triemmen/mappen sykje
Comment[ga]=Aimsigh Comhaid/Comhadlanna
Comment[gl]=Buscar Arquivos
Comment[he]=חפש קבצים או תיקיות
Comment[hr]=Traži datoteke/mape
Comment[hu]=Fájlkereső
Comment[is]=Finna skrár/möppur
Comment[it]=Trova file/cartelle
Comment[ja]=ファイル/フォルダを検索
Comment[km]=រកឯកសារ/ថត
Comment[lt]=Rasti bylas/aplankus
Comment[lv]=Meklēt Failus/Mapes
Comment[mk]=Пронајди датотеки/папки
Comment[ms]=Cari Fail/Folder
Comment[nb]=Finn filer/mapper
Comment[nds]=Dateien/Ornern söken
Comment[nl]=Bestanden/mappen zoeken
Comment[nn]=Finn filer/mapper
Comment[pa]=ਫਾਇਲ/ਫੋਲਡਰ ਖੋਜ
Comment[pl]=Wyszukiwanie plików/katalogów
Comment[pt]=Procurar Ficheiros/Pastas
Comment[pt_BR]=Procurar arquivos/pastas
Comment[ro]=Caută fişiere/foldere
Comment[ru]=Поиск файлов и папок
Comment[rw]=Gushaka Amadosiye/Ububiko
Comment[se]=Oza fiillaid dahje máhpaid
Comment[sk]=Hľadať súbory/priečinky
Comment[sl]=Najdi datoteke in mape
Comment[sr]=Тражење фајлова/фасцикли
Comment[sr@Latn]=Traženje fajlova/fascikli
Comment[sv]=Hitta filer eller kataloger
Comment[ta]=கோப்புகள்/அடைவுகளைக் கண்டுபிடி
Comment[tg]=Ҷустуҷӯи файлҳо/феҳристҳо
Comment[th]=ค้นหาแฟ้ม/โฟลเดอร์
Comment[tr]=Dosya/Dizin Bul
Comment[tt]=Birem/Törgäk Ezläw
Comment[uk]=Пошук файлів та тек
Comment[uz]=Файл/жилдларни қидириш
Comment[vi]=Tìm Tập tin/Thư mục
Comment[zh_CN]=查找文件/文件夹
Comment[zh_TW]=尋找檔案/資料夾
Exec=gnome-search-tool
Icon=normal/MagnifyingGlass2
Terminal=false
Type=Application
Encoding=UTF-8
Categories=SearchTool
X-AfterStep-IndexName=gnome-search-tool
TryExec=gnome-search-tool
[Desktop Entry]
Name=KDE File Search Tool
GenericName=System Search
Comment=Find Files/Folders
Comment[af]=Soek Lêers/Gidse
Comment[bg]=Търсене на файлове
Comment[bn]=ফাইল/ফোল্ডার অনুসন্ধান
Comment[br]=Klask restroù/renkelloù
Comment[bs]=Pronađi datoteke
Comment[ca]=Cerca fitxers i carpetes
Comment[cs]=Najít soubory/složky
Comment[da]=Find filer/mapper
Comment[de]=Dateien/Ordner suchen
Comment[el]=Αναζήτηση αρχείων/φακέλων
Comment[es]=Buscar archivos/carpetas
Comment[et]=Failide/kataloogide otsimine
Comment[eu]=Bilatu fitxategiak/karpetak
Comment[fa]=یافتن پروندهها/پوشهها
Comment[fi]=Etsi tiedostoja ja kansioita
Comment[fr]=Recherche de fichiers/dossiers
Comment[fy]=Triemmen/mappen sykje
Comment[ga]=Aimsigh Comhaid/Comhadlanna
Comment[gl]=Buscar Arquivos
Comment[he]=חפש קבצים או תיקיות
Comment[hr]=Traži datoteke/mape
Comment[hu]=Fájlkereső
Comment[is]=Finna skrár/möppur
Comment[it]=Trova file/cartelle
Comment[ja]=ファイル/フォルダを検索
Comment[km]=រកឯកសារ/ថត
Comment[lt]=Rasti bylas/aplankus
Comment[lv]=Meklēt Failus/Mapes
Comment[mk]=Пронајди датотеки/папки
Comment[ms]=Cari Fail/Folder
Comment[nb]=Finn filer/mapper
Comment[nds]=Dateien/Ornern söken
Comment[nl]=Bestanden/mappen zoeken
Comment[nn]=Finn filer/mapper
Comment[pa]=ਫਾਇਲ/ਫੋਲਡਰ ਖੋਜ
Comment[pl]=Wyszukiwanie plików/katalogów
Comment[pt]=Procurar Ficheiros/Pastas
Comment[pt_BR]=Procurar arquivos/pastas
Comment[ro]=Caută fişiere/foldere
Comment[ru]=Поиск файлов и папок
Comment[rw]=Gushaka Amadosiye/Ububiko
Comment[se]=Oza fiillaid dahje máhpaid
Comment[sk]=Hľadať súbory/priečinky
Comment[sl]=Najdi datoteke in mape
Comment[sr]=Тражење фајлова/фасцикли
Comment[sr@Latn]=Traženje fajlova/fascikli
Comment[sv]=Hitta filer eller kataloger
Comment[ta]=கோப்புகள்/அடைவுகளைக் கண்டுபிடி
Comment[tg]=Ҷустуҷӯи файлҳо/феҳристҳо
Comment[th]=ค้นหาแฟ้ม/โฟลเดอร์
Comment[tr]=Dosya/Dizin Bul
Comment[tt]=Birem/Törgäk Ezläw
Comment[uk]=Пошук файлів та тек
Comment[uz]=Файл/жилдларни қидириш
Comment[vi]=Tìm Tập tin/Thư mục
Comment[zh_CN]=查找文件/文件夹
Comment[zh_TW]=尋找檔案/資料夾
Exec=kfind
Icon=normal/MagnifyingGlass2
Terminal=false
Type=Application
Encoding=UTF-8
Categories=SearchTool
X-AfterStep-IndexName=kfind
TryExec=kfind
[Desktop Entry]
Name=Console Find
GenericName=System Search
Comment=Find Files/Folders
Comment[af]=Soek Lêers/Gidse
Comment[bg]=Търсене на файлове
Comment[bn]=ফাইল/ফোল্ডার অনুসন্ধান
Comment[br]=Klask restroù/renkelloù
Comment[bs]=Pronađi datoteke
Comment[ca]=Cerca fitxers i carpetes
Comment[cs]=Najít soubory/složky
Comment[da]=Find filer/mapper
Comment[de]=Dateien/Ordner suchen
Comment[el]=Αναζήτηση αρχείων/φακέλων
Comment[es]=Buscar archivos/carpetas
Comment[et]=Failide/kataloogide otsimine
Comment[eu]=Bilatu fitxategiak/karpetak
Comment[fa]=یافتن پروندهها/پوشهها
Comment[fi]=Etsi tiedostoja ja kansioita
Comment[fr]=Recherche de fichiers/dossiers
Comment[fy]=Triemmen/mappen sykje
Comment[ga]=Aimsigh Comhaid/Comhadlanna
Comment[gl]=Buscar Arquivos
Comment[he]=חפש קבצים או תיקיות
Comment[hr]=Traži datoteke/mape
Comment[hu]=Fájlkereső
Comment[is]=Finna skrár/möppur
Comment[it]=Trova file/cartelle
Comment[ja]=ファイル/フォルダを検索
Comment[km]=រកឯកសារ/ថត
Comment[lt]=Rasti bylas/aplankus
Comment[lv]=Meklēt Failus/Mapes
Comment[mk]=Пронајди датотеки/папки
Comment[ms]=Cari Fail/Folder
Comment[nb]=Finn filer/mapper
Comment[nds]=Dateien/Ornern söken
Comment[nl]=Bestanden/mappen zoeken
Comment[nn]=Finn filer/mapper
Comment[pa]=ਫਾਇਲ/ਫੋਲਡਰ ਖੋਜ
Comment[pl]=Wyszukiwanie plików/katalogów
Comment[pt]=Procurar Ficheiros/Pastas
Comment[pt_BR]=Procurar arquivos/pastas
Comment[ro]=Caută fişiere/foldere
Comment[ru]=Поиск файлов и папок
Comment[rw]=Gushaka Amadosiye/Ububiko
Comment[se]=Oza fiillaid dahje máhpaid
Comment[sk]=Hľadať súbory/priečinky
Comment[sl]=Najdi datoteke in mape
Comment[sr]=Тражење фајлова/фасцикли
Comment[sr@Latn]=Traženje fajlova/fascikli
Comment[sv]=Hitta filer eller kataloger
Comment[ta]=கோப்புகள்/அடைவுகளைக் கண்டுபிடி
Comment[tg]=Ҷустуҷӯи файлҳо/феҳристҳо
Comment[th]=ค้นหาแฟ้ม/โฟลเดอร์
Comment[tr]=Dosya/Dizin Bul
Comment[tt]=Birem/Törgäk Ezläw
Comment[uk]=Пошук файлів та тек
Comment[uz]=Файл/жилдларни қидириш
Comment[vi]=Tìm Tập tin/Thư mục
Comment[zh_CN]=查找文件/文件夹
Comment[zh_TW]=尋找檔案/資料夾
Exec=ASRun --exec-in-term --cmd find
Icon=normal/MagnifyingGlass
Terminal=false
Type=Application
Encoding=UTF-8
Categories=SearchTool
TryExec=find
[Desktop Entry]
Name=Google Internet Search
GenericName=Internet Search
Comment=Search the World Wide Web using Google.
Exec=ASRun --immidiate --cmd http://www.google.com
Icon=normal/WWW
Terminal=false
Type=Application
Encoding=UTF-8
Categories=SearchTool
TryExec=ASRun
[Desktop Entry]
Name=Yahoo Internet Search
GenericName=Internet Search
Comment=Search the World Wide Web using Yahoo.
Exec=ASRun --immidiate --cmd http://www.yahoo.com
Icon=normal/WWW
Terminal=false
Type=Application
Encoding=UTF-8
Categories=SearchTool
TryExec=ASRun
| 30.212766 | 50 | 0.811127 |
391f448c8cce6abb174df74495a7fe49d1653657 | 195 | desktop | desktop | misc/input-method.desktop | ftake/chameleon-tongue | d64d8a2744e291d370c25ce1670852d8de3c3d06 | [
"BSD-3-Clause"
] | 2 | 2015-04-19T12:07:22.000Z | 2015-12-06T04:11:36.000Z | misc/input-method.desktop | ftake/chameleon-tongue | d64d8a2744e291d370c25ce1670852d8de3c3d06 | [
"BSD-3-Clause"
] | null | null | null | misc/input-method.desktop | ftake/chameleon-tongue | d64d8a2744e291d370c25ce1670852d8de3c3d06 | [
"BSD-3-Clause"
] | null | null | null | [Desktop Entry]
Name=Input Method
GenericName=Start Input Method
Comment=Start Input Method
Exec=/usr/lib/input-method/start-im
Terminal=false
Type=Application
StartupNotify=false
NoDisplay=true
| 19.5 | 35 | 0.841026 |
d4e5d4fad89bc132a87b2559d2392c279d48ce8b | 179 | desktop | desktop | system/vice/config/x128.desktop | panosmdma/SlackOnly-SlackBuilds | 91682df0a8f14aed276b7e27f63a7bde2acc0a34 | [
"MIT"
] | 8 | 2016-01-07T18:53:17.000Z | 2020-06-07T09:51:12.000Z | system/vice/config/x128.desktop | panosmdma/SlackOnly-SlackBuilds | 91682df0a8f14aed276b7e27f63a7bde2acc0a34 | [
"MIT"
] | 2 | 2017-02-07T06:39:27.000Z | 2017-04-29T18:15:36.000Z | system/vice/config/x128.desktop | panosmdma/SlackOnly-SlackBuilds | 91682df0a8f14aed276b7e27f63a7bde2acc0a34 | [
"MIT"
] | 2 | 2018-02-01T07:02:12.000Z | 2020-11-04T07:17:28.000Z | [Desktop Entry]
Name=VICE C128 emulator
Comment=Commodore 128 emulator from the VICE team
StartupNotify=true
Exec=x128
Icon=vice
Terminal=false
Type=Application
Categories=System
| 17.9 | 49 | 0.843575 |
e15a19a5211364447269818125a66e9f5e5e13ec | 227 | desktop | desktop | contrib/debian/bitcoingreen-qt.desktop.desktop | panamcoin/Panam | 6586f74ed3fbee70a92a11bfca924e14dbc6cbc9 | [
"MIT"
] | 1 | 2019-04-17T07:31:28.000Z | 2019-04-17T07:31:28.000Z | contrib/debian/bitcoingreen-qt.desktop.desktop | panamcoin/Panam | 6586f74ed3fbee70a92a11bfca924e14dbc6cbc9 | [
"MIT"
] | null | null | null | contrib/debian/bitcoingreen-qt.desktop.desktop | panamcoin/Panam | 6586f74ed3fbee70a92a11bfca924e14dbc6cbc9 | [
"MIT"
] | 1 | 2020-11-29T12:36:29.000Z | 2020-11-29T12:36:29.000Z | [Desktop Entry]
Encoding=UTF-8
Name=Panam
Comment=Panam P2P Cryptocurrency
Exec=panam-qt %u
Terminal=false
Type=Application
Icon=panam128
MimeType=x-scheme-handler/panam;
Categories=Office;Finance;
Name[en_US]=panam-qt.desktop
| 18.916667 | 32 | 0.823789 |
e47bad10c969a998caf90890d627c0b09ece4a17 | 594 | desktop | desktop | build-aux/snap/local/desktop/remita-qt_testnet.desktop | Remitacoin/rem | 031d57869013b454a9eb7011ed51a0d95264f588 | [
"MIT"
] | 2 | 2021-02-16T19:07:09.000Z | 2021-05-03T13:55:20.000Z | build-aux/snap/local/desktop/remita-qt_testnet.desktop | Remitacoin/rem | 031d57869013b454a9eb7011ed51a0d95264f588 | [
"MIT"
] | 1 | 2021-06-20T01:11:11.000Z | 2021-06-20T01:27:21.000Z | build-aux/snap/local/desktop/remita-qt_testnet.desktop | Remitacoin/remit | 031d57869013b454a9eb7011ed51a0d95264f588 | [
"MIT"
] | null | null | null | # http://standards.freedesktop.org/desktop-entry-spec/desktop-entry-spec-1.0.html
[Desktop Entry]
Encoding=UTF-8
Name=REMIT_Coin
Comment=REMIT_Coin QT test network
GenericName=REMIT_Coin Digital Currency QT client testnet network
Exec=remita_coin-core.qt-testnet %u
Terminal=false
Type=Application
Icon=${SNAP}/share/pixmaps/remita_coin_testnet.png
MimeType=x-scheme-handler/remita;
Categories=X-Office;X-Finance;
Keywords=internet;remita_coin;zremita;tremita;core;wallet;qt;testnet;snap;launchpad;crypto;digital;currency;coin;token;zerocoin;
Version=1.0
Name[en_IN]=remita-qt_testnet.desktop
| 34.941176 | 128 | 0.833333 |
5386d56692f0bfee5fcd71b2d4ccfffde1228410 | 258 | desktop | desktop | contrib/debian/virtualcoin-qt.desktop | xeddmc/virtualcoin | 5cd6639b5a3db28535e987fab0d51e77427fa752 | [
"MIT"
] | null | null | null | contrib/debian/virtualcoin-qt.desktop | xeddmc/virtualcoin | 5cd6639b5a3db28535e987fab0d51e77427fa752 | [
"MIT"
] | null | null | null | contrib/debian/virtualcoin-qt.desktop | xeddmc/virtualcoin | 5cd6639b5a3db28535e987fab0d51e77427fa752 | [
"MIT"
] | null | null | null | [Desktop Entry]
Encoding=UTF-8
Name=Virtualcoin
Comment=VirtualCoin P2P Cryptocurrency
Exec=/usr/bin/darkcoin-qt %u
Terminal=false
Type=Application
Icon=/usr/share/pixmaps/virtualcoin128.png
MimeType=x-scheme-handler/virtualcoin;
Categories=Office; Finance;
| 23.454545 | 42 | 0.833333 |
b9f0ed3fd985f321c56b85355d14eef5d27957f0 | 689 | desktop | desktop | database/pomotroid/pomotroid.desktop | mbunkus/appimage.github.io | 7e4c5c59fcec8dca3feb490dab968fb6dad36358 | [
"MIT"
] | 228 | 2017-08-23T13:35:04.000Z | 2022-03-30T20:57:21.000Z | database/pomotroid/pomotroid.desktop | mbunkus/appimage.github.io | 7e4c5c59fcec8dca3feb490dab968fb6dad36358 | [
"MIT"
] | 1,504 | 2017-08-21T15:06:59.000Z | 2022-03-31T20:22:42.000Z | database/pomotroid/pomotroid.desktop | mbunkus/appimage.github.io | 7e4c5c59fcec8dca3feb490dab968fb6dad36358 | [
"MIT"
] | 530 | 2017-08-23T13:28:42.000Z | 2022-03-31T20:03:25.000Z | [Desktop Entry]
Name=Pomotroid
Comment=A simple and visually-pleasing Pomodoro timer
Exec=AppRun
Terminal=false
Type=Application
Icon=pomotroid
X-AppImage-Version=0.1.2
X-AppImage-BuildId=a40812e0-23b7-11a8-04c1-f1a5803b8164
Categories=Utility;
[AppImageHub]
# Dear upstream developer, please include update information in your AppImage
# (e.g., with appimagetool -u) so that users can easily update the AppImage
X-AppImage-Signature=no valid OpenPGP data found. the signature could not be verified. Please remember that the signature file (.sig or .asc) should be the first file given on the command line.
X-AppImage-Type=2
X-AppImage-Architecture=x86_64
X-AppImage-Payload-License=MIT
| 36.263158 | 194 | 0.811321 |
3bc95da9f72601f5ac91e1d7a076ef429ec39572 | 218 | desktop | desktop | slideshow-exe/slideshow/start.desktop | lexi-lambda/slideshow | 96fb17455eb87f17561dae5b934a3502a52a0b30 | [
"Apache-2.0",
"MIT"
] | 29 | 2015-08-07T20:04:42.000Z | 2021-04-12T05:25:05.000Z | slideshow-exe/slideshow/start.desktop | lexi-lambda/slideshow | 96fb17455eb87f17561dae5b934a3502a52a0b30 | [
"Apache-2.0",
"MIT"
] | 19 | 2015-08-05T04:26:57.000Z | 2020-10-21T15:43:33.000Z | share/pkgs/slideshow-exe/slideshow/start.desktop | takikawa/racket-ppa | d336bb10e3e0ec3a20020e9ade9e77d2f6f80b6d | [
"MIT"
] | 15 | 2016-06-20T12:20:42.000Z | 2022-03-30T15:59:45.000Z | [Desktop Entry]
Name=Slideshow
GenericName=Slide-presentation tool
Comment=Slideshow is a Racket-based tool for writing slide presentations as programs
Terminal=false
Type=Application
Categories=Graphics;Presentation;
| 27.25 | 84 | 0.857798 |
631e2052ef4502215e355a0b359dd33916c273aa | 90 | desktop | desktop | home/yggdrasil/files/share/applications/file.desktop | nicolas-graves/dotfiles | 41bf96e408d4cd623d633bb6f8a142b87758b1ce | [
"BSD-3-Clause"
] | 3 | 2022-02-07T20:21:20.000Z | 2022-03-18T19:14:49.000Z | home/yggdrasil/files/share/applications/file.desktop | nicolas-graves/dotfiles | 41bf96e408d4cd623d633bb6f8a142b87758b1ce | [
"BSD-3-Clause"
] | null | null | null | home/yggdrasil/files/share/applications/file.desktop | nicolas-graves/dotfiles | 41bf96e408d4cd623d633bb6f8a142b87758b1ce | [
"BSD-3-Clause"
] | null | null | null | [Desktop Entry]
Type=Application
Name=File Manager
Exec=/usr/local/bin/alacritty -e lf %u
| 18 | 38 | 0.777778 |
5bc163022631ca1e4f96f55a16559c5f41dd1f59 | 90 | desktop | desktop | ansible/roles/iot_baby/files/serial-monitor.desktop | andrasmaroy/iot_baby | 9a328d10b7dfa6a366b08c7303b57b0101ffa9d3 | [
"MIT"
] | null | null | null | ansible/roles/iot_baby/files/serial-monitor.desktop | andrasmaroy/iot_baby | 9a328d10b7dfa6a366b08c7303b57b0101ffa9d3 | [
"MIT"
] | 7 | 2022-02-13T23:00:13.000Z | 2022-02-13T23:21:36.000Z | ansible/roles/iot_baby/files/serial-monitor.desktop | andrasmaroy/iot_baby | 9a328d10b7dfa6a366b08c7303b57b0101ffa9d3 | [
"MIT"
] | null | null | null | [Desktop Entry]
Type=Application
Name=Serial Plotter
Exec="/home/pi/iot_baby/iot_baby.py"
| 18 | 36 | 0.8 |
04b0fe3bb00413a96cd1cbc2ba478ae304227b76 | 174 | desktop | desktop | config/Desktop/RPI-Monitor.desktop | ksbjr/KickPi-OS_up | e52389f2d263b3cb0eda766e7c5d356e3ade21e6 | [
"BSD-3-Clause"
] | null | null | null | config/Desktop/RPI-Monitor.desktop | ksbjr/KickPi-OS_up | e52389f2d263b3cb0eda766e7c5d356e3ade21e6 | [
"BSD-3-Clause"
] | null | null | null | config/Desktop/RPI-Monitor.desktop | ksbjr/KickPi-OS_up | e52389f2d263b3cb0eda766e7c5d356e3ade21e6 | [
"BSD-3-Clause"
] | 2 | 2022-01-13T15:37:07.000Z | 2022-03-02T18:15:11.000Z | [Desktop Entry]
Version=1.0
Type=Link
Name=RPI-Monitor
Comment=
Icon=novell-button
URL=https://localhost:10000/sysinfo.cgi?xnavigation=1
Categories=Settings;DesktopSettings;
| 19.333333 | 53 | 0.821839 |
103c536317bdceba73bc2b2689ab70cd3282ce93 | 166 | desktop | desktop | matlab2020b.desktop | davidbradway/linux-workstation-custom | 7f974eeebfebddd2ab363c85c4dadfb396128637 | [
"MIT",
"Unlicense"
] | null | null | null | matlab2020b.desktop | davidbradway/linux-workstation-custom | 7f974eeebfebddd2ab363c85c4dadfb396128637 | [
"MIT",
"Unlicense"
] | null | null | null | matlab2020b.desktop | davidbradway/linux-workstation-custom | 7f974eeebfebddd2ab363c85c4dadfb396128637 | [
"MIT",
"Unlicense"
] | null | null | null | [Desktop Entry]
Name=Matlab2020b
Comment=Run Matlab 2020b desktop
Exec=matlab -desktop&
Terminal=false
Type=Application
StartupNotify=true
Categories=Development;IDE
| 18.444444 | 32 | 0.849398 |
bde356a2f963a33c42057def139f35bb904b4ab4 | 403 | desktop | desktop | contrib/debian/novacoin-qt.desktop | nano-project/nanocoin | fdf7bccf62e741fd5fd29f5dbc0b486c7086aba7 | [
"MIT"
] | null | null | null | contrib/debian/novacoin-qt.desktop | nano-project/nanocoin | fdf7bccf62e741fd5fd29f5dbc0b486c7086aba7 | [
"MIT"
] | null | null | null | contrib/debian/novacoin-qt.desktop | nano-project/nanocoin | fdf7bccf62e741fd5fd29f5dbc0b486c7086aba7 | [
"MIT"
] | null | null | null | [Desktop Entry]
Encoding=UTF-8
Name=NanoCoin
Comment=NanoCoin P2P Cryptocurrency
Comment[ru]=NanoCoin, P2P криптовалюта
Comment[fr]=NanoCoin, monnaie virtuelle cryptographique pair à pair
Comment[tr]=NanoCoin, eşten eşe kriptografik sanal para birimi
Exec=/usr/bin/NanoCoin-qt
Terminal=false
Type=Application
Icon=/usr/share/pixmaps/NanoCoin80.xpm
MimeType=x-scheme-handler/NanoCoin;
Categories=Office;
| 28.785714 | 67 | 0.831266 |
b21170af764f63fa73359c07f513695854a16ca1 | 125 | desktop | desktop | Makefile.desktop | GeekJoystick/game-and-watch-game-engine | c00a64371c3a98d57b950b1acd94008392fb7b2e | [
"BSD-3-Clause"
] | 7 | 2021-01-03T15:25:25.000Z | 2021-07-25T23:39:34.000Z | Makefile.desktop | GeekJoystick/game-and-watch-game-engine | c00a64371c3a98d57b950b1acd94008392fb7b2e | [
"BSD-3-Clause"
] | null | null | null | Makefile.desktop | GeekJoystick/game-and-watch-game-engine | c00a64371c3a98d57b950b1acd94008392fb7b2e | [
"BSD-3-Clause"
] | null | null | null | C_INCLUDES = \
-ICore/Inc/Engine \
all:
g++ Core/Src/main.cpp -o main -lSDL2 -Wall -O2 -DDESKTOP -DCOMPILING $(C_INCLUDES) | 25 | 83 | 0.688 |
50d4f43785d2de41e38efdf13bc94c7622361132 | 137 | desktop | desktop | FilesRemote.desktop | allanrbo/filesremote | e0dfd083d915af023dc85da0434954b641ec15d6 | [
"MIT"
] | 385 | 2020-12-24T03:39:23.000Z | 2022-03-20T13:13:12.000Z | FilesRemote.desktop | allanrbo/FilesRemote | 0c0cc01a225f477459c2655d236b1682f50f8548 | [
"MIT"
] | 7 | 2021-08-19T15:18:47.000Z | 2022-03-31T06:56:38.000Z | FilesRemote.desktop | allanrbo/FilesRemote | 0c0cc01a225f477459c2655d236b1682f50f8548 | [
"MIT"
] | 18 | 2021-06-13T04:05:14.000Z | 2022-03-14T03:35:05.000Z | [Desktop Entry]
Type=Application
Name=FilesRemote
Comment=An SFTP file manager
Icon=FilesRemote
Exec=/usr/bin/filesremote
Terminal=false
| 17.125 | 28 | 0.839416 |
c0f7d173b6a267f35a7ad4f295853da229574be0 | 191 | desktop | desktop | lib/cytoscape_3_3/cytoscape.desktop | BioDepot/noVNC-CyNetworkBMA | c5a95aea49b79a803e9e42ab77e5a405f29bd4e0 | [
"MIT"
] | 24 | 2016-04-12T15:46:13.000Z | 2022-02-02T10:34:31.000Z | lib/cytoscape_3_3/cytoscape.desktop | BioDepot/noVNC-CyNetworkBMA | c5a95aea49b79a803e9e42ab77e5a405f29bd4e0 | [
"MIT"
] | 2 | 2016-02-26T10:13:59.000Z | 2016-03-07T05:11:54.000Z | lib/cytoscape_3_3/cytoscape.desktop | BioDepot/noVNC-CyNetworkBMA | c5a95aea49b79a803e9e42ab77e5a405f29bd4e0 | [
"MIT"
] | 14 | 2015-09-12T21:04:01.000Z | 2020-10-06T15:36:24.000Z | [Desktop Entry]
Encoding=UTF-8
Type=Application
Name=Cytoscape
Name[en_US]=Cytoscape
Exec=lxterminal -e '/deps/cytoscape-unix-3.3.0/cytoscape.sh'
Comment[en_US]=Cytoscape
StartupNotify=true
| 19.1 | 60 | 0.806283 |
2cf870aeac52c59e579a6697dc82569544ab306c | 224 | desktop | desktop | desktop/trimage.desktop | Acidburn0zzz/Trimage | e47888e06780ebfbd988f00b7444f6143dc7677a | [
"MIT"
] | null | null | null | desktop/trimage.desktop | Acidburn0zzz/Trimage | e47888e06780ebfbd988f00b7444f6143dc7677a | [
"MIT"
] | null | null | null | desktop/trimage.desktop | Acidburn0zzz/Trimage | e47888e06780ebfbd988f00b7444f6143dc7677a | [
"MIT"
] | null | null | null | [Desktop Entry]
Name=Trimage image compressor
Comment=A cross-platform tool for optimizing PNG and JPG files.
Terminal=false
Icon=trimage
Type=Application
Exec=trimage
Categories=Application;Qt;Graphics;
StartupNotify=true
| 20.363636 | 63 | 0.839286 |
8cc9956101b69c7648d4aefd5638694beef7243e | 205 | desktop | desktop | config/xminad.desktop | michojel/xminad | e51d0103b1c5646b77fabaedde5cd0f416c980b9 | [
"BSD-3-Clause"
] | null | null | null | config/xminad.desktop | michojel/xminad | e51d0103b1c5646b77fabaedde5cd0f416c980b9 | [
"BSD-3-Clause"
] | null | null | null | config/xminad.desktop | michojel/xminad | e51d0103b1c5646b77fabaedde5cd0f416c980b9 | [
"BSD-3-Clause"
] | null | null | null | [Desktop Entry]
Type=Application
Name=XMinad
Exec={{BIN_DIR}}/xminad
NoDisplay=true
X-GNOME-WMName=XMinad
X-GNOME-Autostart-Phase=WindowManager
X-GNOME-Provides=windowmanager
X-GNOME-Autostart-Notify=true
| 20.5 | 37 | 0.829268 |
84be43f002ce6aeec01445def0147612cd376567 | 116 | desktop | desktop | pulsemodule/eqpro_gui/freedesktop/pulseaudio-eqpro-gui.desktop | pac85/audioeqpro | 9b9be7eed74dbd229c9a645a3847f6f857e8f0cd | [
"MIT"
] | 11 | 2016-11-09T21:12:10.000Z | 2020-10-07T06:47:08.000Z | pulsemodule/eqpro_gui/freedesktop/pulseaudio-eqpro-gui.desktop | pac85/audioeqpro | 9b9be7eed74dbd229c9a645a3847f6f857e8f0cd | [
"MIT"
] | 1 | 2016-11-14T10:59:43.000Z | 2016-11-14T10:59:43.000Z | pulsemodule/eqpro_gui/freedesktop/pulseaudio-eqpro-gui.desktop | pac85/audioeqpro | 9b9be7eed74dbd229c9a645a3847f6f857e8f0cd | [
"MIT"
] | 6 | 2016-11-12T15:21:40.000Z | 2018-11-15T20:08:41.000Z | [Desktop Entry]
Name=eqpro settings
Exec=/usr/bin/eqpro-gui
Icon=eqpro-icon
Type=Application
Categories=Audio;
| 16.571429 | 24 | 0.775862 |
0e032258d88a9efc4100c0240137b594437d7d29 | 201 | desktop | desktop | srcpkgs/jre/files/java-policy-settings.desktop | xdave/xbps-packages | 98903b086a03b69e3fc95c17dad4590671ca5f13 | [
"BSD-1-Clause"
] | 5 | 2020-03-16T20:00:54.000Z | 2022-01-06T04:03:39.000Z | srcpkgs/jre/files/java-policy-settings.desktop | xdave/xbps-packages | 98903b086a03b69e3fc95c17dad4590671ca5f13 | [
"BSD-1-Clause"
] | 1 | 2019-05-08T09:32:23.000Z | 2019-05-08T09:40:57.000Z | srcpkgs/jre/files/java-policy-settings.desktop | xdave/xbps-packages | 98903b086a03b69e3fc95c17dad4590671ca5f13 | [
"BSD-1-Clause"
] | null | null | null | [Desktop Entry]
Exec=policytool
Icon=sun-java.png
Name[cs]=Nastavení politiky Java aplikací
Name=Java Policy Settings
Path=
StartupNotify=true
Terminal=false
Type=Application
Categories=Settings;Java;
| 18.272727 | 41 | 0.835821 |
2c834b4544528cf54a2b1bda3a3cd497603cad6d | 206 | desktop | desktop | domain.desktop | pvdrz/domain | a7693342409f70767ec44edac78759f06c4af508 | [
"BlueOak-1.0.0",
"Apache-2.0"
] | null | null | null | domain.desktop | pvdrz/domain | a7693342409f70767ec44edac78759f06c4af508 | [
"BlueOak-1.0.0",
"Apache-2.0"
] | 1 | 2021-11-15T23:38:13.000Z | 2021-11-17T16:23:37.000Z | domain.desktop | pvdrz/domain | a7693342409f70767ec44edac78759f06c4af508 | [
"BlueOak-1.0.0",
"Apache-2.0"
] | null | null | null | [Desktop Entry]
Type=Application
Name=Domain
Icon=signal-desktop
Exec=/usr/local/bin/domain
Terminal=true
Categories=Network;InstantMessaging;
Keywords=sgnl;chat;im;messaging;messenger;sms;security;privat;
| 22.888889 | 62 | 0.839806 |
fd69647a03bced52a35339db6b355e5751345b8c | 163 | desktop | desktop | debian/desktop/eclipse.desktop | summerclouds/image-ide | ccfe0983eca8f6324efe2c72d559f4611bf2ef0e | [
"Apache-2.0"
] | null | null | null | debian/desktop/eclipse.desktop | summerclouds/image-ide | ccfe0983eca8f6324efe2c72d559f4611bf2ef0e | [
"Apache-2.0"
] | null | null | null | debian/desktop/eclipse.desktop | summerclouds/image-ide | ccfe0983eca8f6324efe2c72d559f4611bf2ef0e | [
"Apache-2.0"
] | null | null | null | [Desktop Entry]
Version=1.0
Type=Application
Name=Eclipse
Comment=
Exec=/usr/local/eclipse/eclipse
Icon=
Path=/usr/local/eclipse
Terminal=true
StartupNotify=false
| 14.818182 | 31 | 0.815951 |
7a3f7fb50acb3aac7c2113d783753b1a5248c200 | 1,218 | desktop | desktop | blondie/matchbox/theme.desktop | fatman2021/AmbasaOS-Themes | 56eed889e55f6b02d7b205f1c2958c277d745516 | [
"Unlicense"
] | null | null | null | blondie/matchbox/theme.desktop | fatman2021/AmbasaOS-Themes | 56eed889e55f6b02d7b205f1c2958c277d745516 | [
"Unlicense"
] | null | null | null | blondie/matchbox/theme.desktop | fatman2021/AmbasaOS-Themes | 56eed889e55f6b02d7b205f1c2958c277d745516 | [
"Unlicense"
] | null | null | null | [Desktop Entry]
#
# The theme.desktop file for a matchbox theme is a basic way to
# set the look of things other than the window manager when the
# theme is changed.
#
# Currently it controls the dock and mbmenu's look .
# 'Standard' .desktop entries.
#
Type=MBTheme
Name=Blondie
Comment=Blondie theme
#
# Dock/Panel settings
#
# you can set the docks background color, or to a tiled pixmap / transparent
DockBgColor=#e2dec6
#DockBgTrans= 0-255, 0 being totally transparent
#DockBgPixmap=/path/to/a xpm or png
# The foreground color is used by things like minitime
PanelFgColor=black
# Panel bubble message propertys
PanelMsgBgCol=#e2dec6
PanelMsgBgUrgentCol=#ffdec6
PanelMsgFgCol=#000000
#
# Menu settings, used by both the dock popup menu and mbmenu.
#
MenuBgColor=#e2dec6
MenuFgColor=black
# menu Border color
MenuBdColor=#9d9a8a
# selected entry color.
# MenuHlColor=black XXX DEPRECIATED in 0.7 , border col used instead
# Menu transparency set like the panel
# MenuTransparency=0-255
# Set to a '|' seperated list of font names.
# if set will overide Gtk font from xsettings
#MenuFont=xxx|xxx|xxx
# Value same as mbdesktop --bg option
DesktopBgSpec=col-solid:#8395ac
DesktopHlCol=#9d9a8a
| 21 | 76 | 0.762726 |
a92cf51fcab554c8a4f96af490188f9dca4c8561 | 290 | desktop | desktop | .themes/Nordic GTK/kde/aurorae/Nordic/metadata.desktop | historical-theology/theological-dots | 6e588e9df2991de66a699d415c22be62a6e5c386 | [
"CC0-1.0"
] | 1 | 2021-09-18T17:12:41.000Z | 2021-09-18T17:12:41.000Z | .themes/Nordic GTK/kde/aurorae/Nordic/metadata.desktop | historical-theology/theological-dots | 6e588e9df2991de66a699d415c22be62a6e5c386 | [
"CC0-1.0"
] | null | null | null | .themes/Nordic GTK/kde/aurorae/Nordic/metadata.desktop | historical-theology/theological-dots | 6e588e9df2991de66a699d415c22be62a6e5c386 | [
"CC0-1.0"
] | null | null | null | [Desktop Entry]
Name=Nordic
X-KDE-PluginInfo-Author=eliverlara
X-KDE-PluginInfo-Category=
X-KDE-PluginInfo-Depends=
X-KDE-PluginInfo-Email=eliverlara@gmail.com
X-KDE-PluginInfo-EnabledByDefault=true
X-KDE-PluginInfo-License=GPLv3
X-KDE-PluginInfo-Name=Nordic
X-KDE-PluginInfo-Version=1.0.0
| 26.363636 | 43 | 0.827586 |
faf62c0ca4ae2808f4bcfc5bbdbe52d44fe39bcb | 249 | desktop | desktop | GTASA/SAMP.desktop | mattroot/wine-games | 923991fed335fc25d449255a4343027c588935c9 | [
"MIT"
] | 1 | 2020-02-07T22:08:01.000Z | 2020-02-07T22:08:01.000Z | GTASA/SAMP.desktop | mattroot/wine-games | 923991fed335fc25d449255a4343027c588935c9 | [
"MIT"
] | null | null | null | GTASA/SAMP.desktop | mattroot/wine-games | 923991fed335fc25d449255a4343027c588935c9 | [
"MIT"
] | 1 | 2020-02-15T18:58:09.000Z | 2020-02-15T18:58:09.000Z | [Desktop Entry]
Name=San Andreas Multiplayer
Comment=Start San Andreas Multiplayer
Exec=$HOME/.local/share/wineprefixes/GTASA/runscript.sh samp.exe
Icon=SAMP
Terminal=false
Type=Application
Categories=Game;
StartupNotify=true
StartupWMClass=samp.exe | 24.9 | 64 | 0.84739 |
0b259eabe1403d817f155845f4e4807292af25fd | 191 | desktop | desktop | dynamd/dynamd.desktop | m0lese/dynamd | bcf4b60d7fa9ae9413627a20e9dcfc0cbd77b112 | [
"MIT"
] | 2 | 2021-08-22T20:29:09.000Z | 2021-09-25T17:27:44.000Z | dynamd/dynamd.desktop | m0lese/dynamd | bcf4b60d7fa9ae9413627a20e9dcfc0cbd77b112 | [
"MIT"
] | 21 | 2021-06-30T14:26:30.000Z | 2021-10-01T07:35:57.000Z | src/dynamd.desktop | loannaflip/dynamd | f1b32d36af0230e2f94612827d5144aa5da99891 | [
"MIT"
] | 1 | 2022-01-08T05:21:58.000Z | 2022-01-08T05:21:58.000Z | [Desktop Entry]
Encoding=UTF-8
Name=dynamd
GenericName=Dynamd Window Manager
Comment=Dynamd Window Manager
Keywords=dynamd;window manager;
TryExec=dynamd
Exec=dynamd
Icon=dynamd
Type=XSession | 19.1 | 33 | 0.848168 |
679c9f892ccfcaa81719d5d6a878a49b25d4e818 | 573 | desktop | desktop | src/blackrosewallet.desktop | Camellia73/BlackRoseCoin_GUI | ede33fb4ec27f56987422e2d1da9f91b5077ec17 | [
"MIT"
] | null | null | null | src/blackrosewallet.desktop | Camellia73/BlackRoseCoin_GUI | ede33fb4ec27f56987422e2d1da9f91b5077ec17 | [
"MIT"
] | null | null | null | src/blackrosewallet.desktop | Camellia73/BlackRoseCoin_GUI | ede33fb4ec27f56987422e2d1da9f91b5077ec17 | [
"MIT"
] | null | null | null | [Desktop Entry]
Encoding=UTF-8
Name=BlackRose
GenericName=BlackRose wallet
Name[uk]=BlackRose wallet
Name[ru]=BlackRose wallet
Name[pl]=BlackRose wallet
Name[be]=BlackRose wallet
Name[de]=BlackRose wallet
Name[es]=BlackRose wallet
Comment=BlackRose wallet
Comment[uk]=BlackRose wallet
Comment[ru]=BlackRose wallet
Comment[pl]=BlackRose wallet
Comment[be]=BlackRose wallet
Comment[de]=BlackRose wallet
Comment[es]=BlackRose wallet
Exec=blackrose %U
Terminal=false
Type=Application
Icon=blackrose
MimeType=x-scheme-handler/blackrose;
Categories=Office;Finance;
Version=2.4.2
| 22.92 | 36 | 0.827225 |
fc9c5a9c636bf63ad42c2fd6cfd552667641b95e | 245 | desktop | desktop | qualcoder/GUI/qualcoder.desktop | FantasqueX/QualCoder | 11a9c593fab0bbcf9f55b14501deee878d264e8d | [
"MIT"
] | null | null | null | qualcoder/GUI/qualcoder.desktop | FantasqueX/QualCoder | 11a9c593fab0bbcf9f55b14501deee878d264e8d | [
"MIT"
] | null | null | null | qualcoder/GUI/qualcoder.desktop | FantasqueX/QualCoder | 11a9c593fab0bbcf9f55b14501deee878d264e8d | [
"MIT"
] | null | null | null | [Desktop Entry]
Name=QualCoder
Type=Application
Version=2.9
Comment=Qualitiatve data analysis
Exec=python3 -m qualcoder
Icon=/usr/share/icons/qualcoder128.png
Terminal=false
Keywords=QDA;Social Science;
Categories=Science;
Name[en_AU]=QualCoder
| 20.416667 | 38 | 0.832653 |
6991730f15a32c0fe09f93ee475b5b809762d49b | 156 | desktop | desktop | implementation/rosa/smartcard-screensaver.desktop | mikhailnov/2fa-tuner-lib | 4de6ad63b0ea9248da2af68da8e0caf7598cc908 | [
"MIT"
] | null | null | null | implementation/rosa/smartcard-screensaver.desktop | mikhailnov/2fa-tuner-lib | 4de6ad63b0ea9248da2af68da8e0caf7598cc908 | [
"MIT"
] | 10 | 2020-03-25T12:05:52.000Z | 2020-03-25T14:12:58.000Z | implementation/rosa/smartcard-screensaver.desktop | mikhailnov/2fa-tuner-lib | 4de6ad63b0ea9248da2af68da8e0caf7598cc908 | [
"MIT"
] | 2 | 2021-03-25T04:33:43.000Z | 2021-03-25T14:33:09.000Z | [Desktop Entry]
Type=Application
Name=Smart Card Screensaver
Comment=Application to lock screen on smart card removal.
Exec=/usr/bin/pkcs11_eventmgr daemon
| 26 | 57 | 0.833333 |
065663eed44e19ab8c632abc20aa339f49e6b28c | 202 | desktop | desktop | config/Desktop/Google-Chrome.desktop | DrSnowbird/jre-mvn-py3-X11 | 07f2a4754e3a27ea8bdd5302f06907c71b9afb76 | [
"Apache-2.0"
] | 6 | 2018-04-30T21:48:26.000Z | 2021-03-24T09:06:21.000Z | config/Desktop/Google-Chrome.desktop | DrSnowbird/jre-mvn-py3-X11 | 07f2a4754e3a27ea8bdd5302f06907c71b9afb76 | [
"Apache-2.0"
] | null | null | null | config/Desktop/Google-Chrome.desktop | DrSnowbird/jre-mvn-py3-X11 | 07f2a4754e3a27ea8bdd5302f06907c71b9afb76 | [
"Apache-2.0"
] | 4 | 2018-07-18T20:04:56.000Z | 2022-01-11T06:55:36.000Z | [Desktop Entry]
Version=1.0
Type=Application
Name=Google Chrome
Comment=Access the Internet
Exec=/usr/bin/google-chrome-stable %U --no-sandbox
Icon=google-chrome
Path=
Terminal=false
StartupNotify=true
| 18.363636 | 50 | 0.811881 |
7d37cc6efe20083032826da2f6bdaf66fa3626a1 | 243 | desktop | desktop | iss-vm/iss-vm-system/Desktop/Solution WeChat Software Robot.desktop | telescopeuser/iss-misc | cd09f30ee597cc93d833207daad824f658b07293 | [
"MIT"
] | null | null | null | iss-vm/iss-vm-system/Desktop/Solution WeChat Software Robot.desktop | telescopeuser/iss-misc | cd09f30ee597cc93d833207daad824f658b07293 | [
"MIT"
] | null | null | null | iss-vm/iss-vm-system/Desktop/Solution WeChat Software Robot.desktop | telescopeuser/iss-misc | cd09f30ee597cc93d833207daad824f658b07293 | [
"MIT"
] | null | null | null | [Desktop Entry]
Version=1.0
Comment=This is launcher
Exec=/home/iss-user/.DoNotDelete/start-wechat-robot-py3.sh
Icon=/home/iss-user/.DoNotDelete/png-wechat-green.png
Terminal=true
Type=Application
Name[en_SG]=Solution WeChat Software Robot
| 27 | 58 | 0.802469 |
a9748d054afc06eb446050f55f49a17e1ec9e959 | 5,879 | ec | eC | samples/3D/HoloLensModelViewer/modelViewer.ec | mingodad/ecere-sdk | f24d82827e750d8ee0cd52c0abdc87b8fe3b7e96 | [
"BSD-3-Clause"
] | 264 | 2015-01-08T22:19:27.000Z | 2022-03-25T19:33:03.000Z | samples/3D/HoloLensModelViewer/modelViewer.ec | mingodad/ecere-sdk | f24d82827e750d8ee0cd52c0abdc87b8fe3b7e96 | [
"BSD-3-Clause"
] | 34 | 2015-11-07T07:48:18.000Z | 2022-02-05T09:13:55.000Z | samples/3D/HoloLensModelViewer/modelViewer.ec | mingodad/ecere-sdk | f24d82827e750d8ee0cd52c0abdc87b8fe3b7e96 | [
"BSD-3-Clause"
] | 91 | 2015-01-08T22:19:28.000Z | 2022-01-10T10:14:38.000Z | import "ecere"
#define _GLES3
#include "gl123es.h"
ModelWindow modelWindow;
class ModelWindow : Window
{
displayDriver = "OpenGL";
caption = $"Ecere Model Viewer";
opacity = 0;
drawBehind = false;
anchor = { left = 0, top = 0, right = 0, bottom = 0 };
Camera camera
{
fixedQuaternion,
fovDirection = vertical,
fov = 53,
eulerOrientation = Euler { 0, 0, 0 },
zMin = 1;
zMax = 10000;
};
Object model {};
Light light
{
diffuse = white;
specular = white;
orientation = Euler { pitch = 50, yaw = 45 };
};
const char * modelFile;
void OnUnloadGraphics()
{
model.Free(displaySystem);
displaySystem.ClearMaterials();
displaySystem.ClearTextures();
displaySystem.ClearMeshes();
}
void OnDestroy()
{
delete model;
model = { };
}
void OnResize(int w, int h)
{
camera.Setup(w, h, null);
Update(null);
}
bool OnKeyDown(Key key, unichar ch)
{
switch(key)
{
case escape: Destroy(0); return false;
}
return true;
}
bool OnLoadGraphics()
{
if(model.Load(modelFile, null, displaySystem))
{
float r = model.radius;
//float s = 0.08 / r; // Avocado
float s = 20.0f / r; // Sponza / Buildings
model.transform.scaling = { s, s, s };
model.UpdateTransform();
Log("OnLoadGraphics(): Successfully loaded 3D model!\n");
camera.zMin = 0.01; //1;
camera.zMax = 100;
// Sponza
camera.position = { 0, -1.6, 0 },
// Buildings
//camera.position = { 0, -0.3, 0 },
// Avocado
//camera.position = { 0, 0, -0.25 }; //r * 2 };
// camera.eulerOrientation = Euler { 30, 0, 0 };
light.orientation = Euler { pitch = 50, yaw = 45 };
return true;
}
return false;
}
void OnRedraw(Surface surface)
{
Vector3D p, o;
display.fogDensity = 0;
surface.SetBackground(0);
surface.Clear(colorAndDepth);
app.updateCamera();
p = camera.position;
o.Add(p, hmdPosition);
camera.orientation = hmdOrientation;
camera.position = o;
camera.Update();
display.SetLight(0, &light);
display.SetCamera(surface, camera);
display.ambient = { 30, 30, 30 }; //black;
display.DrawObject(model);
display.SetCamera(surface, null);
camera.position = p;
renderedSinceLastCycle = true;
}
}
static bool renderedSinceLastCycle = true;
class HoloLensApp : GuiApplication
{
driver = "OpenGL";
bool Init()
{
static char modelPath[MAX_LOCATION];
UseSingleGLContext(true);
modelWindow = { };
incref modelWindow;
strcpy(modelPath, installedPath);
//PathCat(modelPath, "Avocado.e3d"); //Assets/E3D/Avocado.e3d");
PathCat(modelPath, "sponza.e3d");
//PathCat(modelPath, "buildings-tateyo.e3d");
modelWindow.modelFile = modelPath;
return modelWindow.Create();
}
void updateCamera()
{
static bool firstTime = true;
if(!firstTime)
{
Matrix matrix, inverse;
Euler hmdEuler;
#if defined(__UWP__)
float mat[16];
glGetFloatv(GLEXT_HOLOGRAPHIC_MONO_VIEW_MATRIX_ANGLE, mat);
matrix =
{ {
mat[ 0], mat[ 1], mat[ 2], mat[ 3],
mat[ 4], mat[ 5], mat[ 6], mat[ 7],
mat[ 8], mat[ 9], mat[10], mat[11],
mat[12], mat[13], mat[14], mat[15]
} };
#else
matrix.Identity();
#endif
inverse.Inverse(matrix);
inverse.Scale(1,1,-1);
hmdEuler.FromMatrix(inverse, yxz);
hmdEuler.yaw *= -1;
hmdEuler.roll *= -1;
hmdEuler.yaw += 180;
hmdOrientation = hmdEuler;
hmdPosition = { -inverse.array[12], -inverse.array[13], inverse.array[14] };
}
firstTime = false;
}
bool Cycle(bool idle)
{
if(!modelWindow || modelWindow.destroyed || !renderedSinceLastCycle)
return true;
modelWindow.Update(null);
return true;
}
void Terminate()
{
delete modelWindow;
}
}
Euler hmdOrientation;
Vector3D hmdPosition;
HoloLensApp app;
char installedPath[MAX_LOCATION];
default:
dllexport bool __stdcall __ecereDll_Load(Module module);
dllexport bool __stdcall __ecereDll_Unload(Module module);
dllexport int E3DViewer_Init(int argc, const char ** argv, const uint16 * widePath)
{
int result = 0;
app = (HoloLensApp)__ecere_COM_Initialize(true, argc, (char **)argv);
if(app)
{
Module module = eModule_LoadStatic(app, "modelViewer", publicAccess, __ecereDll_Load, __ecereDll_Unload);
if(module)
{
eInstance_Evolve(&app, class(HoloLensApp));
SetLoggingMode(debug, null);
Log("Successfully loaded modelViewer module!\n");
LocateModule(null, installedPath);
StripLastDirectory(installedPath, installedPath);
UTF16toUTF8Buffer(widePath, (char *)installedPath, sizeof(installedPath));
Logf("Installed path: %s\n", installedPath);
result = app.Init();
if(result)
{
app.desktop.opacity = 0;
app.desktop.drawBehind = false;
Log("HoloLensApp initialization successful!\n");
}
}
}
return result;
}
static int desktopW, desktopH;
dllexport void E3DViewer_Cycle(int w, int h)
{
if(w == -1 && h == -1) w = 2048, h = 1080;
if(desktopW != w || desktopH != h)
{
app.SetDesktopPosition(0, 0, w, h, true);
desktopW = w;
desktopH = h;
}
app.Cycle(false);
app.ProcessInput(true);
}
dllexport void E3DViewer_Render()
{
app.UpdateDisplay();
}
dllexport void E3DViewer_Terminate()
{
delete app;
}
| 21.223827 | 111 | 0.576969 |
bd12193e8aaa085b83909aeb7efab002aa35330e | 197 | ec | eC | tools/embedded-c/test.ec | block8437/FailSafeC | 1458e382518ba8b56f680436873c3b42a89e1636 | [
"Apache-2.0"
] | 1 | 2018-02-10T02:52:09.000Z | 2018-02-10T02:52:09.000Z | tools/embedded-c/test.ec | block8437/FailSafeC | 1458e382518ba8b56f680436873c3b42a89e1636 | [
"Apache-2.0"
] | null | null | null | tools/embedded-c/test.ec | block8437/FailSafeC | 1458e382518ba8b56f680436873c3b42a89e1636 | [
"Apache-2.0"
] | null | null | null | <%#shared
#include <errno.h>
#%>
<%#libs -lm #%>
<%#cflags -Wall #%>
#define EINVAL <%=d EINVAL %>
#define ESOMETHING <%[[%><%#onerror (-1)#%><%=d ESOMETHING %><%]]%>
#define EFAULT <%=d EFAULT %>
| 21.888889 | 67 | 0.548223 |
4faad0ee4f279c9ae8c194414b5197f4b854b009 | 60,939 | ec | eC | ecere/src/gui/controls/Menu.ec | Acidburn0zzz/ecere-sdk | 6eb4d438465e75a2459a07d6724d0ca2296304ce | [
"BSD-3-Clause"
] | null | null | null | ecere/src/gui/controls/Menu.ec | Acidburn0zzz/ecere-sdk | 6eb4d438465e75a2459a07d6724d0ca2296304ce | [
"BSD-3-Clause"
] | null | null | null | ecere/src/gui/controls/Menu.ec | Acidburn0zzz/ecere-sdk | 6eb4d438465e75a2459a07d6724d0ca2296304ce | [
"BSD-3-Clause"
] | null | null | null | namespace gui::controls;
import "Window"
private define SELECTION_COLOR = guiApp.currentSkin.selectionColor; //Color { 10, 36, 106 };
private define SELECTION_TEXT = guiApp.currentSkin.selectionText; //Color { 10, 36, 106 };
private define menuBarColor = Color { 211, 218, 237 };
private define popupMenuColor = Color { 229,234,245 };
class ItemPtr : struct
{
ItemPtr prev, next;
MenuItem item, oldItem;
InsertedFlags inserted;
Window master;
};
#define ITEM_DISABLED(i) ((i).disabled || ((i).subMenu && !(i).subMenu.items.count))
class InsertedFlags { bool deleteLink:1, deleteItem:1, cleanItem:1, placed:1; };
#define ITEM_TEXT(item) (item.subMenu ? item.subMenu.text : item.text)
#define ITEM_HOTKEY(item) (item.subMenu ? item.subMenu.hotKey : item.hotKey)
#define DIVIDER_HEIGHT (guiApp.textMode ? textCellH : 8)
#define INTERIM_MENU (isMenuBar || interim)
//#define INTERIM_MENU interim
static int strcmpTillTab(char * a, char * b)
{
if(a && !b) return 1;
else if(b && !a) return -1;
else
{
int c;
for(c = 0; a[c] && b[c] && a[c] != '\t' && b[c] != '\t'; c++)
if(a[c] > b[c]) return 1;
else if(b[c] > a[c]) return -1;
if(a[c] && a[c] != '\t') return 1;
else if(b[c] && b[c] != '\t') return -1;
return 0;
}
}
public class MenuItem
{
public:
property Menu parent
{
set
{
if(menu != value)
{
if(menu)
menu.RemoveItem(this);
if(value)
value.AddItem(this);
}
}
};
property char * text
{
set
{
if(copyText)
{
delete text;
text = CopyString(value);
}
else
text = value;
manualAccelText = (value && strchr(value, '\t'));
if(accelerator && !manualAccelText)
property::accelerator = accelerator;
}
};
property Key hotKey { set { hotKey = value; } };
property Key accelerator
{
set
{
accelerator = value;
if(!manualAccelText && text)
{
char accelString[50] = "\t";
char * newText;
char * tabPos;
int length = 0;
if(value.ctrl) strcat(accelString, $"Ctrl+");
if(value.alt) strcat(accelString, $"Alt+");
if(value.shift) strcat(accelString, $"Shift+");
if(value.code == k0)
strcat(accelString, "0");
else if(value.code >= k1 && value.code <= k9)
{
accelString[strlen(accelString)] = '1' + (char)(value.code - k1);
accelString[strlen(accelString)+1] = 0;
}
else
{
Key accel = value.code;
bool needClass = false;
char tempString[50];
char * result = accel.OnGetString(tempString, null, &needClass);
int len = strlen(accelString);
if(result) strcpy(accelString + len, result);
// accelString[len] = toupper(accelString[len]);
}
tabPos = strchr(text, '\t');
if(tabPos)
length = tabPos - text;
else
length = strlen(text);
newText = new char[length+strlen(accelString)+1];
memcpy(newText, text, length);
newText[length] = 0;
strcat(newText, accelString);
if(copyText) delete text;
text = newText;
copyText = true;
}
}
};
property bool checked
{
set
{
checked = value;
if(menu && radio && value)
{
// Find the group
ItemPtr groupFirst = menu.items.first;
ItemPtr otherItemPtr;
for(otherItemPtr = menu.items.first; otherItemPtr; otherItemPtr = otherItemPtr.next)
{
MenuItem otherItem = otherItemPtr.item;
if(otherItem.isDivider)
groupFirst = otherItemPtr.next;
else if(!otherItem.placement)
{
if(otherItem == this)
break;
}
}
for(otherItemPtr = groupFirst; otherItemPtr; otherItemPtr = otherItemPtr.next)
{
MenuItem otherItem = otherItemPtr.item;
if(otherItem.isDivider)
break;
else if(!otherItem.placement && otherItem.radio && otherItem != this)
otherItem.checked = false;
}
}
// Should callback be called here? guess not ;)
}
get { return checked; }
};
property bool disabled { set { if(this) disabled = value; } };
property bool checkable { set { checkable = value; } };
property bool isRadio { set { radio = value; } };
property uint64 id { set { id = value; } get { return id; } };
property BitmapResource bitmap
{
set
{
delete bitmaps[0];
delete bitmaps[1];
delete bitmaps[2];
bitmaps[0] = value;
bitmaps[1] = value ? (value.alphaBlend ? value : { fileName = value.fileName, monochrome = true }) : null;
bitmaps[2] = value ? { fileName = value.fileName, grayed = true } : null;
if(value)
{
incref bitmaps[0];
incref bitmaps[1];
incref bitmaps[2];
}
}
get { return bitmaps[0]; }
};
property bool copyText
{
set
{
if(value)
{
if(text && !copyText)
text = CopyString(ITEM_TEXT(this));
}
else
{
if(text && copyText)
delete text;
}
copyText = value;
}
};
property bool bold { set { bold = value; } get { return bold; } };
virtual bool Window::NotifySelect(MenuItem selection, Modifiers mods);
private:
bool isDivider;
bool placement;
uint64 id;
Key hotKey;
Key accelerator;
char * text;
BitmapResource bitmaps[3];
bool checkable, radio;
bool checked;
bool disabled;
Menu menu;
Menu subMenu;
bool copyText;
bool manualAccelText;
bool bold;
~MenuItem()
{
if(copyText)
// delete ITEM_TEXT(this);
delete text;
delete subMenu;
delete bitmaps[0];
delete bitmaps[1];
delete bitmaps[2];
}
};
public class MenuDivider : MenuItem
{
MenuDivider()
{
isDivider = true;
}
// property Menu parent { set {} };
};
public class MenuPlacement : MenuItem
{
MenuPlacement()
{
placement = true;
}
public:
/*
property Menu parent { set {} };
property char * text { set {} };
property Key hotKey { set {} };
*/
};
public class Menu
{
class_no_expansion
int OnCompare(Menu menu)
{
return (this != null) != (menu != null);
}
public:
void AddItem(MenuItem item)
{
if(item)
{
ItemPtr ptr;
for(ptr = items.first; ptr; ptr = ptr.next)
{
MenuItem check = ptr.item;
if(check.placement)
{
if(!strcmpTillTab(ITEM_TEXT(check), ITEM_TEXT(item)))
break;
}
}
if(!ptr)
{
ptr = ItemPtr { };
items.Add(ptr);
}
else
{
ptr.inserted = InsertedFlags { placed = true };
ptr.oldItem = ptr.item;
}
ptr.item = item;
incref item;
if(!item.placement)
itemCount++;
// TOCHECK:
item.menu = this;
}
}
void RemoveItem(MenuItem item)
{
if(item.menu == this)
{
ItemPtr ptr;
for(ptr = items.first; ptr; ptr = ptr.next)
if(ptr.item == item)
{
if(ptr.inserted.placed)
{
ptr.item = ptr.oldItem;
ptr.oldItem = null;
}
if(!item.placement)
itemCount--;
item.menu = null;
if(!ptr.inserted.placed)
items.Delete(ptr);
else
ptr.inserted = 0;
delete item;
break;
}
}
}
void AddSubMenu(Menu subMenu)
{
if(subMenu)
{
MenuItem menuItem { };
ItemPtr ptr { item = menuItem };
items.Add(ptr);
incref menuItem;
itemCount++;
// TOCHECK:
menuItem.menu = this;
if(subMenu)
{
menuItem.subMenu = subMenu;
incref subMenu;
}
}
}
void AddDynamic(MenuItem addedItem, Window master, bool persistent)
{
if(addedItem)
{
ItemPtr ptr = null, oldItemPtr;
for(oldItemPtr = items.first; oldItemPtr; oldItemPtr = oldItemPtr.next)
{
if((oldItemPtr.item.subMenu || oldItemPtr.item.placement) && !strcmpTillTab(ITEM_TEXT(oldItemPtr.item), ITEM_TEXT(addedItem)))
{
MenuItem oldItem = oldItemPtr.item;
if(!oldItem.placement)
{
oldItem.subMenu.Merge(addedItem.subMenu, true, master);
}
// If sub menu already has a master...
else
{
oldItemPtr.inserted = InsertedFlags { cleanItem = true };
if(!oldItemPtr.oldItem)
oldItemPtr.oldItem = oldItem;
oldItemPtr.item = addedItem;
}
ptr = oldItemPtr;
break;
}
}
if(!ptr)
{
ptr = ItemPtr { };
items.Add(ptr);
if(!persistent)
ptr.inserted = InsertedFlags { deleteLink = true, deleteItem = true };
}
else if(!persistent)
ptr.inserted = InsertedFlags { cleanItem = true, deleteItem = true };
ptr.item = addedItem;
ptr.master = master;
incref addedItem;
itemCount++;
addedItem.menu = this;
}
}
MenuItem FindItem(bool (* Window::notifySelect)(MenuItem selection, Modifiers mods), uint64 id)
{
ItemPtr ptr;
for(ptr = items.first; ptr; ptr = ptr.next)
{
MenuItem item = ptr.item;
if(item.subMenu)
{
MenuItem subItem = item.subMenu.FindItem(notifySelect, id);
if(subItem) return subItem;
}
else if(!item.isDivider && !item.placement)
{
if(item.id == id && item.NotifySelect == notifySelect)
return item;
}
}
return null;
}
void Clear()
{
ItemPtr ptr;
while((ptr = items.first))
{
delete ptr.item;
if(ptr.inserted.cleanItem || ptr.inserted.placed)
{
ptr.item = ptr.oldItem;
ptr.oldItem = null;
delete ptr.item;
}
items.Delete(ptr);
}
}
void Merge(Menu menuBeingMerged, bool menuBar, Window window)
{
bool separated = false;
ItemPtr beingMergedItemPtr;
for(beingMergedItemPtr = menuBeingMerged.items.first; beingMergedItemPtr; beingMergedItemPtr = beingMergedItemPtr.next)
{
MenuItem beingMergedItem = beingMergedItemPtr.item;
ItemPtr mergeIntoItemPtr = null;
if(!beingMergedItem) continue;
if(beingMergedItem.subMenu)
{
for(mergeIntoItemPtr = items.first; mergeIntoItemPtr; mergeIntoItemPtr = mergeIntoItemPtr.next)
{
if((mergeIntoItemPtr.item.subMenu || mergeIntoItemPtr.item.placement) && !strcmpTillTab(ITEM_TEXT(mergeIntoItemPtr.item), ITEM_TEXT(beingMergedItem)))
{
MenuItem mergeIntoItem = mergeIntoItemPtr.item;
if(!beingMergedItem.placement || beingMergedItemPtr.inserted)
{
if(!mergeIntoItem.placement && !mergeIntoItemPtr.inserted.cleanItem) // Added this last check for ActiveChild overriding ActiveClient's menu
{
mergeIntoItem.subMenu.Merge(beingMergedItem.subMenu, menuBar, window);
}
// If sub menu already has a master...
else
{
mergeIntoItemPtr.inserted = InsertedFlags { cleanItem = true };
if(!mergeIntoItemPtr.oldItem)
mergeIntoItemPtr.oldItem = mergeIntoItem;
mergeIntoItemPtr.item = beingMergedItem;
}
mergeIntoItemPtr.master = window;
itemCount++;
}
break;
}
}
}
else if(!beingMergedItem.isDivider)
{
for(mergeIntoItemPtr = items.first; mergeIntoItemPtr; mergeIntoItemPtr = mergeIntoItemPtr.next)
{
MenuItem mergeIntoItem = mergeIntoItemPtr.item;
if(/*!mergeIntoItem.subMenu && /-*mergeIntoItem.placement && !mergeIntoItemPtr.inserted && */!strcmpTillTab(ITEM_TEXT(mergeIntoItem), ITEM_TEXT(beingMergedItem)))
{
//if(!beingMergedItem.placement || beingMergedItemPtr.inserted)
{
mergeIntoItemPtr.inserted = InsertedFlags { cleanItem = true };
if(!mergeIntoItemPtr.oldItem)
mergeIntoItemPtr.oldItem = mergeIntoItem;
mergeIntoItemPtr.item = beingMergedItem;
mergeIntoItemPtr.master = beingMergedItemPtr.master ? beingMergedItemPtr.master : window;
itemCount++;
}
break;
}
}
}
if(!mergeIntoItemPtr)
{
if(beingMergedItem.placement && !beingMergedItemPtr.inserted)
{
// Simply add the placement at the end
mergeIntoItemPtr = ItemPtr { };
mergeIntoItemPtr.inserted = InsertedFlags { deleteLink = true, cleanItem = true };
mergeIntoItemPtr.item = beingMergedItem;
mergeIntoItemPtr.master = beingMergedItemPtr.master ? beingMergedItemPtr.master : window;
items.Add(mergeIntoItemPtr);
itemCount++;
}
else
{
ItemPtr previous = items.last;
if(menuBar)
{
// If it is a menu bar, add the item before the first divider
for(previous = items.first; previous; previous = previous.next)
if(previous.item.isDivider && !previous.inserted) // Added previous.inserted check
{
previous = previous.prev;
break;
}
}
else
{
if(previous && !previous.item.isDivider && !separated)
{
ItemPtr ptr
{
item = MenuDivider { },
inserted = InsertedFlags { deleteLink = true, deleteItem = true }
};
items.Insert(previous, ptr);
previous = ptr;
separated = true;
itemCount++;
}
}
if(!beingMergedItem.isDivider || !previous || (previous.item && !previous.item.isDivider))
{
mergeIntoItemPtr = ItemPtr { };
items.Insert(previous, mergeIntoItemPtr);
mergeIntoItemPtr.inserted = InsertedFlags { deleteLink = true, cleanItem = true };
mergeIntoItemPtr.item = beingMergedItem;
mergeIntoItemPtr.master = beingMergedItemPtr.master ? beingMergedItemPtr.master : window;
itemCount++;
}
}
}
}
}
void Clean(Window window)
{
ItemPtr ptr, next;
for(ptr = items.first; ptr; ptr = next)
{
MenuItem item = ptr.item;
next = ptr.next;
if(ptr.inserted.cleanItem)
{
ptr.item = ptr.oldItem;
ptr.oldItem = null;
}
else if(item.subMenu)
item.subMenu.Clean(window);
if(ptr.inserted.deleteItem)
delete item;
if(ptr.inserted.deleteLink || ptr.inserted.cleanItem)
itemCount--;
if(ptr.inserted.deleteLink)
items.Delete(ptr);
else
{
ptr.inserted.deleteLink = false;
ptr.inserted.cleanItem = false;
ptr.inserted.deleteItem = false;
ptr.master = window;
}
}
}
Menu FindMenu(char * name)
{
ItemPtr ptr;
for(ptr = items.first; ptr; ptr = ptr.next)
{
MenuItem item = ptr.item;
if(item.subMenu && item.subMenu.text && !strcmpTillTab(item.subMenu.text, name))
return item.subMenu;
}
return null;
}
property Menu parent { set { if(value) value.AddSubMenu(this); } };
property char * text { set { text = value; /* CopyString(value);*/ } };
property Key hotKey { set { hotKey = value; } };
property bool hasMargin { set { hasMargin = value; } };
private:
OldList items;
char * text;
int hotKey;
int w, h;
Color color;
int itemHeight;
int itemCount;
bool mergeClients;
bool hasMargin;
Menu()
{
color = popupMenuColor;
}
~Menu()
{
Clean(null);
Clear();
}
};
public class PopupMenu : Window
{
class_property(icon) = "<:ecere>controls/menu.png";
bool isMenuBar;
int rw, rh;
int totalHeight;
Menu menu;
ItemPtr selected;
bool pressed;
bool altDown;
bool keyboardFocus;
bool mouseInput;
Time unpressedTime;
void (* FontExtent)(Display display, Font font, char * text, int len, int * width, int * height);
FontResource boldFont { faceName = font.faceName, font.size, bold = true, window = this };
BitmapResource subArrow { fileName = "<:ecere>elements/arrowRight.png", window = this };
BitmapResource whiteSubArrow { fileName = "<:ecere>elements/arrowRight.png", monochrome = true, window = this };
BitmapResource disabledSubArrow { fileName = "<:ecere>elements/arrowRight.png", grayed = true, window = this };
borderStyle = bevel;
interim = true;
~PopupMenu()
{
if(menu) delete menu;
}
// Utility Functions
bool MenuDestroyMasters(bool unselect)
{
bool result;
PopupMenu window = this, master;
PopupMenu popupMenu;
for(; (master = (PopupMenu)window.master); window = master)
{
if(!eClass_IsDerived(master._class, _class) || master.isMenuBar)
break;
}
if(eClass_IsDerived(master._class, _class) && master.isMenuBar)
{
master.pressed = false;
if(unselect)
{
master.keyboardFocus = false;
master.selected = null;
}
master.Update(null);
}
result = window.Destroy(0);
// This looks like a hack...
RestoreCaret();
return result;
}
bool MenuGoToPrevItem()
{
ItemPtr selected, current = this.selected;
for(selected = (current && current.prev) ? current.prev : menu.items.last;
selected &&
(selected.item.isDivider || selected.item.placement || ITEM_DISABLED(selected.item)) &&
selected != current;
selected = selected.prev ? selected.prev : menu.items.last)
{
if(!current) current = selected; // Endless loop with no previously selected popups
}
this.selected = selected;
return selected && selected != current;
}
bool MenuGoToNextItem()
{
ItemPtr selected, current = this.selected;
for(selected = (current && current.next) ? current.next : menu.items.first;
selected &&
(selected.item.isDivider || selected.item.placement || ITEM_DISABLED(selected.item)) &&
selected != current;
selected = selected.next ? selected.next : menu.items.first)
{
if(!current) current = selected; // Endless loop with no previously selected popups
}
this.selected = selected;
return selected && selected != current;
}
void MenuPopupChild(int x, int y, Menu childMenu)
{
if(childMenu)
{
RestoreCaret();
if(childMenu.itemCount)
{
PopupMenu child { master = this, menu = childMenu };
if(INTERIM_MENU)
{
Window parent = this.parent;
Window desktop = guiApp.desktop;
x += parent.absPosition.x + parent.clientStart.x - desktop.position.x;
y += parent.absPosition.y + parent.clientStart.y - desktop.position.y;
/*
x += parent.absPosition.x + parent.clientStart.x;
y += parent.absPosition.y + parent.clientStart.y;
*/
child.parent = desktop;
}
else
{
child.stayOnTop = true;
child.parent = parent;
child.interim = false;
}
child.position = Point { x, y };
// child.id = id;
// child.displayDriver = "GDI";
child.Create();
}
}
}
bool MenuPopupSelected()
{
if(isMenuBar)
{
int selectedX = guiApp.textMode ? 0 : 2;
if(selected && selected.item) // Why was this null from OnKeyHit?
{
ItemPtr selected = this.selected, ptr;
bool helpBreak = false;
Window parent = this.parent;
Window activeClient = parent.activeClient;
bool systemButtons = activeClient && activeClient.state == maximized;
keyboardFocus = true;
pressed = true;
//if(!INTERIM_MENU)
if(firstSlave)
firstSlave.Destroy(0);
for(ptr = menu.items.first; ptr; ptr = ptr.next)
{
MenuItem item = ptr.item;
int len;
if(item.placement) continue; //&& !ptr.inserted) continue;
if(ptr == selected)
{
Menu childMenu = item.subMenu;
this.selected = ptr;
if(selected.item.subMenu)
MenuPopupChild(selectedX, 0, childMenu);
keyboardFocus = true;
pressed = true;
this.selected = ptr;
Update(null);
return false; // true
}
if(item.isDivider)
{
if(!helpBreak)
{
ItemPtr nextPtr;
int breakX = clientSize.w + 2 - (systemButtons ? 48 : 0);
for(nextPtr = ptr.next; nextPtr; nextPtr = nextPtr.next)
{
MenuItem nextItem = nextPtr.item;
if(!nextItem.isDivider && ITEM_TEXT(nextItem))
{
int len;
FontExtent(display, fontObject, ITEM_TEXT(nextItem), strlen(ITEM_TEXT(nextItem)), &len, null);
breakX -= len + 16;
}
}
if(selectedX < breakX) selectedX = breakX;
helpBreak = true;
}
}
else if(ITEM_TEXT(item))
{
FontExtent(display, fontObject, ITEM_TEXT(item), strlen(ITEM_TEXT(item)), &len, null);
selectedX += len + 16;
}
}
Update(null);
}
}
else
{
if(selected && selected.item.subMenu)
{
Menu childMenu = selected.item.subMenu;
int y = 0;
int selectedY = 0;
ItemPtr ptr;
for(ptr = menu.items.first; ptr; ptr = ptr.next)
{
MenuItem item = ptr.item;
if(item.placement) continue; //&& !ptr.inserted) continue;
if(selected == ptr)
{
selectedY = y;
break;
}
y += (item.isDivider) ? DIVIDER_HEIGHT : rh;
}
if(ptr)
{
PopupMenu slave = (PopupMenu)firstSlave;
if(!slave || slave.menu != childMenu)
{
if(firstSlave) firstSlave.Destroy(0);
MenuPopupChild(position.x + size.w, position.y + selectedY, childMenu);
Update(null);
return true;
}
}
}
}
return false;
}
bool MenuItemSelection(Menu parentMenu, ItemPtr selectionPtr, Key key)
{
MenuItem selection = selectionPtr.item;
if(!ITEM_DISABLED(selection))
{
Window master = this;
if(!isMenuBar)
master = master.master;
if(selectionPtr.master)
master = selectionPtr.master;
while(eClass_IsDerived(master._class, _class) && master.master)
master = master.master;
if(selection.checkable)
selection.checked = !selection.checked;
else if(selection.radio)
{
if(selection.checked) return false;
selection.checked = !selection.checked;
}
if(!isMenuBar)
MenuDestroyMasters(true);
/*return */selection.NotifySelect(master, selection, key.modifiers);
return true;
}
return false;
}
bool CheckAccelerators(Menu menu, Key key)
{
ItemPtr ptr;
for(ptr = menu.items.first; ptr; ptr = ptr.next)
{
MenuItem item = ptr.item;
if(item.subMenu)
{
if(!CheckAccelerators(item.subMenu, key))
return false;
}
else if(!item.isDivider)
{
if(item.accelerator == key)
{
if(MenuItemSelection(menu, ptr, key))
return false;
}
}
}
return true;
}
ItemPtr FindSelected(int mx, int my, int * selectedX, int * selectedY)
{
Menu menu = this.menu;
// Mouse moved inside menu
ItemPtr selected = null;
*selectedX = 0;
*selectedY = 0;
if(isMenuBar && menu)
{
ItemPtr ptr;
int x = 0;
int len;
bool helpBreak = false;
Window parent = this.parent;
Window activeClient = parent.activeClient;
bool systemButtons = activeClient && activeClient.state == maximized;
for(ptr = menu.items.first; ptr; ptr = ptr.next)
{
MenuItem item = ptr.item;
if(item.placement) continue; //&& !ptr.inserted) continue;
if(item.isDivider)
{
if(!helpBreak)
{
ItemPtr nextPtr;
int breakX = clientSize.w - (systemButtons ? 48 : 0);
for(nextPtr = ptr.next; nextPtr; nextPtr = nextPtr.next)
{
MenuItem nextItem = nextPtr.item;
if(!nextItem.isDivider && ITEM_TEXT(nextItem))
{
int len;
FontExtent(display, fontObject, ITEM_TEXT(nextItem), strlen(ITEM_TEXT(nextItem)), &len, null);
breakX -= len + 16;
}
}
if(x < breakX) x = breakX;
helpBreak = true;
}
}
else
{
char * text = ITEM_TEXT(item);
FontExtent(display, fontObject, text, text ? strlen(text) : 0, &len, null);
if((mx >= x - 16 && mx < x + len + 16))
{
if(!ITEM_DISABLED(item))
selected = ptr;
if(guiApp.textMode)
*selectedX = x;
else
*selectedX = x + 2;
*selectedY = -position.y;
break;
}
x += len + 16;
}
}
}
else if(menu)
{
ItemPtr ptr;
int y = 0;
for(ptr = menu.items.first; ptr; ptr = ptr.next)
{
MenuItem item = ptr.item;
if(item.placement) continue; //&& !ptr.inserted) continue;
if(mx >= 2 && (my >= y && my < y + rh) && !item.isDivider)
{
if(!ITEM_DISABLED(item))
selected = ptr;
*selectedY = y;
*selectedX = position.x + size.w;
break;
}
if(guiApp.textMode)
y += textCellH;
else
y += (item.isDivider) ? DIVIDER_HEIGHT : rh;
}
}
return selected;
}
// Window Overrides
void OnRedraw(Surface surface)
{
bool hasMargin = menu ? menu.hasMargin : false;
int x = 0;
int y = 0;
int height;
bool helpBreak = false;
Window parent = this.parent;
Window activeClient = parent.activeClient;
bool systemButtons = activeClient && activeClient.state == maximized;
int bitmapOffset = 0;
bool hasBitmap = false;
bool isRadio = false;
surface.TextFont(fontObject);
surface.TextExtent(" ", 1, null, &height);
surface.SetBackground(SELECTION_COLOR);
if(!isMenuBar)
{
if(menu)
{
ItemPtr ptr;
for(ptr = menu.items.first; ptr; ptr = ptr.next)
{
if(ptr.item.bitmaps[0])
{
hasBitmap = true;
break;
}
}
for(ptr = menu.items.first; ptr; ptr = ptr.next)
{
if(ptr.item.radio)
{
isRadio = true;
break;
}
}
}
if(guiApp.textMode)
bitmapOffset = 16;
else
bitmapOffset = hasMargin ? 27 : (hasBitmap ? 18 : 12);
if(hasBitmap && isRadio)
bitmapOffset += 18;
}
else if(guiApp.textMode)
bitmapOffset = 8;
else
{
// Shiny gradient for menu bar
ColorKey keys[2] =
{
{ white, 0 },
{ popupMenuColor, 1 }
};
surface.Gradient(keys, sizeof(keys)/sizeof(ColorKey), 1, vertical, 0,0, clientSize.w-1, 7);
}
if(menu)
{
ItemPtr ptr;
for(ptr = menu.items.first; ptr; ptr = ptr.next)
{
MenuItem item = ptr.item;
if(item.placement) continue; //&& !ptr.inserted) continue;
if(!isMenuBar && selected == ptr)
{
surface.SetForeground(SELECTION_TEXT);
if(guiApp.textMode)
{
surface.TextOpacity(true);
surface.Area(0,y,clientSize.w-1,y+rh-1);
}
else
surface.Area(/*(hasMargin ? bitmapOffset : 0) +*/ 2,y,clientSize.w-3,y+rh);
}
else
{
surface.SetForeground(foreground);
if(guiApp.textMode)
surface.TextOpacity(false);
}
if(item.isDivider)
{
if(isMenuBar)
{
if(!helpBreak)
{
ItemPtr nextPtr;
int breakX = clientSize.w - (systemButtons ? 48 : 0);
for(nextPtr = ptr.next; nextPtr; nextPtr = nextPtr.next)
{
MenuItem nextItem = nextPtr.item;
int len;
if(!nextItem.isDivider && ITEM_TEXT(nextItem))
{
surface.TextExtent(ITEM_TEXT(nextItem), strlen(ITEM_TEXT(nextItem)), &len, null);
breakX -= len + 16;
}
}
if(x < breakX) x = breakX;
helpBreak = true;
}
}
else
{
if(guiApp.textMode)
{
surface.SetForeground(Color { 85, 85, 85 });
surface.DrawingChar(196);
surface.HLine(x + 2, x + rw - 5, y + (rh) / 2);
surface.DrawingChar(' ');
}
else
{
int start = x + hasMargin ? bitmapOffset : 2;
int end = x + rw - (hasMargin ? 13 : 5);
surface.foreground = Color { 85, 85, 85 };
surface.HLine(start, end, y + (DIVIDER_HEIGHT) / 2);
surface.foreground = white;
surface.HLine(start, end, y + (DIVIDER_HEIGHT) / 2 + 1);
}
}
}
else
{
if(selected == ptr && guiApp.textMode)
{
surface.SetBackground(SELECTION_COLOR);
surface.SetForeground(SELECTION_TEXT /*background*/);
surface.TextOpacity(true);
}
if(guiApp.textMode)
{
Interface::WriteKeyedTextDisabled(surface, x + bitmapOffset,
y + (rh - height)/2, ITEM_TEXT(item), ITEM_HOTKEY(item), ITEM_DISABLED(item));
if(item.checked)
surface.WriteText(x, y, "\373", 1);
}
else
{
int textY = y + (rh - height)/2;
BitmapResource bitmap = item.disabled ? item.bitmaps[2] : ((selected == ptr) ? item.bitmaps[1] : item.bitmaps[0]);
if(!isMenuBar && bitmap)
{
Bitmap icon = bitmap.bitmap;
if(icon)
surface.Blit(icon, x + (isRadio ? 18 : 0) + (hasMargin ? 5 : 3), y + (rh - icon.height)/2, 0,0, icon.width, icon.height);
}
if(item.bold)
surface.TextFont(boldFont.font);
else
surface.TextFont(fontObject);
if(ITEM_DISABLED(item) && selected == ptr)
{
surface.SetForeground(formColor);
Interface::WriteKeyedText(surface, x + bitmapOffset + 5,
textY, ITEM_TEXT(item), ITEM_HOTKEY(item));
}
else
Interface::WriteKeyedTextDisabled(surface, x + bitmapOffset + 5,
textY, ITEM_TEXT(item), ITEM_HOTKEY(item), ITEM_DISABLED(item));
// A nice vertical separation line
if(hasMargin && !isMenuBar)
{
surface.foreground = Color { 85, 85, 85 };
surface.VLine(clientArea.top, clientArea.bottom, x + bitmapOffset - 2);
surface.foreground = white;
surface.VLine(clientArea.top, clientArea.bottom, x + bitmapOffset - 1);
}
surface.foreground = foreground;
if(item.checked)
{
surface.DrawLine(x+5, y+9, x+8,y+12);
surface.DrawLine(x+5, y+10, x+8,y+13);
surface.DrawLine(x+8, y+12, x+12,y+4);
surface.DrawLine(x+8, y+13, x+12,y+5);
}
}
}
if(!isMenuBar)
{
// Draw little arrow
if(item.subMenu)
{
surface.SetForeground(foreground);
if(guiApp.textMode)
{
surface.SetForeground((selected == ptr) ? (background) : (foreground));
surface.WriteText(clientSize.w-8, y+(rh - 8)/2, "\020", 1);
}
else
{
Bitmap arrow = (selected == ptr) ? whiteSubArrow.bitmap : subArrow.bitmap;
if(ITEM_DISABLED(ptr.item)) arrow = disabledSubArrow.bitmap;
if(arrow)
surface.Blit(arrow, clientSize.w-14, y+(rh - 8)/2, 0,0, arrow.width, arrow.height);
/*
surface.VLine(y+(rh - 8)/2, y+(rh - 8)/2+7, clientSize.w-10);
surface.SetForeground(Color { 85, 85, 85 });
surface.DrawLine(clientSize.w-10, y+(rh - 8)/2, clientSize.w-4, y+rh / 2);
surface.SetForeground(formColor);
surface.DrawLine(clientSize.w-10, y+(rh - 8)/2+7, clientSize.w-4, y+rh / 2);
*/
}
}
if(guiApp.textMode)
y += rh;
else
y += (item.isDivider) ? DIVIDER_HEIGHT : rh;
}
else if(ITEM_TEXT(item) && !item.isDivider)
{
int len;
surface.TextExtent(ITEM_TEXT(item), strlen(ITEM_TEXT(item)), &len, null);
if(selected == ptr && !guiApp.textMode &&
(item.subMenu || selected))
{
surface.Bevel(pressed, x, y, len+10, height + 6);
}
if(!item.isDivider)
x += len + 16;
}
}
}
}
bool OnKeyDown(Key key, unichar ch)
{
bool result = true;
if(visible)
{
// Non-Interim menus: the slaves don't have focus... pass it down from menu bar
if(!INTERIM_MENU)
{
if(!active && firstSlave)
{
if(!firstSlave.OnKeyDown(key, ch))
result = false;
}
}
switch(key)
{
case leftAlt:
case rightAlt:
if(!isMenuBar)
{
altDown = false;
MenuDestroyMasters(true);
}
else
{
altDown = true;
}
return false;
default:
altDown = false;
if(key && menu)
{
ItemPtr ptr;
for(ptr = menu.items.first; ptr; ptr = ptr.next)
{
MenuItem item = ptr.item;
if((item.placement && !ptr.inserted) || ITEM_DISABLED(item)) continue;
if(((keyboardFocus || !isMenuBar) && ITEM_HOTKEY(item) == key) || (ITEM_HOTKEY(item) | Key { alt = true }) == key)
{
if(!item.isDivider && !item.subMenu)
{
if(MenuItemSelection(menu, ptr, key))
return false;
}
else if(item.subMenu)
{
selected = ptr;
MenuPopupSelected();
result = false;
}
break;
}
}
if(ch >= 32 && ch != 128 && !isMenuBar)
result = false;
}
}
// Interim menus: the slaves are the ones with the focus
if(result && INTERIM_MENU)
{
Window master = this.master;
if(eClass_IsDerived(master._class, _class))
{
if(!master.OnKeyDown(key, ch))
result = false;
}
}
}
return result;
}
bool OnKeyUp(Key key, unichar ch)
{
switch(key)
{
case leftAlt:
case rightAlt:
if(isMenuBar && altDown)
{
if(!selected)
{
MenuGoToNextItem();
keyboardFocus = true;
RestoreCaret();
}
else
{
selected = null;
if(firstSlave) firstSlave.Destroy(0);
pressed = false;
keyboardFocus = false;
RestoreCaret();
}
Update(null);
altDown = false;
return false;
}
break;
}
altDown = false;
return true;
}
bool OnKeyHit(Key key, unichar ch)
{
bool result = true;
if(key == leftAlt || key == rightAlt) return true;
if(key && isMenuBar)
{
if(!keyboardFocus)
{
if(key)
result = CheckAccelerators(menu, key);
if(result && !key.alt && key != escape)
return true;
}
}
if(result && visible)
{
// Non-Interim menus: the slaves don't have focus... pass it down from menu bar
if(!INTERIM_MENU)
{
if(!active && firstSlave)
{
if(!firstSlave.OnKeyHit(key, ch))
result = false;
}
}
if(result)
{
switch(key)
{
case home:
if(!isMenuBar)
{
selected = menu.items.last;
if(MenuGoToNextItem())
Update(null);
result = false;
}
break;
case end:
if(!isMenuBar)
{
selected = menu.items.first;
if(MenuGoToPrevItem())
Update(null);
result = false;
}
break;
case left:
if(isMenuBar)
{
if(MenuGoToPrevItem())
MenuPopupSelected();
result = false;
}
else
{
PopupMenu master = (PopupMenu)this.master;
if(master && !master.isMenuBar)
{
Destroy(0);
if(!INTERIM_MENU)
master.Activate();
result = false;
}
}
break;
case right:
if(isMenuBar)
{
if(MenuGoToNextItem() && MenuPopupSelected())
result = false;
}
else
{
if(selected && !ITEM_DISABLED(selected.item))
{
if(!MenuPopupSelected())
{
if(!selected)
{
selected = menu.items.first;
Update(null);
}
}
else
result = false;
}
else if(!((PopupMenu)master).isMenuBar)
{
if(MenuGoToNextItem())
Update(null);
result = false;
}
}
break;
case space:
if(isMenuBar)
{
if(!pressed)
return MenuPopupSelected();
else
{
pressed = false;
if(firstSlave) firstSlave.Destroy(0);
Update(null);
}
}
break;
case down: case Key::altDown:
if(isMenuBar)
{
return MenuPopupSelected();
}
else
{
if(MenuGoToNextItem())
Update(null);
result = false;
}
break;
case up: case altUp:
if(!isMenuBar)
{
if(MenuGoToPrevItem())
Update(null);
result = false;
}
break;
case enter: case altEnter:
case keyPadEnter: case altKeyPadEnter:
if(selected)
{
if(!selected.item.isDivider && !selected.item.subMenu)
{
if(MenuItemSelection(menu, selected, key))
result = false;
}
}
break;
case escape:
if(isMenuBar)
{
result = selected ? false : true;
selected = null;
pressed = false;
keyboardFocus = false;
RestoreCaret();
Update(null);
return result;
}
else
{
PopupMenu master = (PopupMenu)this.master;
if(eClass_IsDerived(master._class, _class) && master.isMenuBar)
{
ItemPtr selected = master.selected;
Destroy(0);
master.pressed = true;
master.selected = selected;
master.keyboardFocus = true;
}
else
Destroy(0);
result = false;
}
break;
default:
if(key && menu)
{
//ItemPtr ptr;
if(ch >= 32 && !isMenuBar)
return false;
/*
for(ptr = menu.items.first; ptr; ptr = ptr.next)
{
MenuItem item = ptr.item;
if((item.placement && !ptr.inserted) || ITEM_DISABLED(item)) continue;
if(ITEM_HOTKEY(item) == key || (ITEM_HOTKEY(item) | Key { alt = true }) == key)
{
if(!item.isDivider && !item.subMenu)
{
if(MenuItemSelection(menu, ptr, key))
return false;
}
else if(item.subMenu)
{
selected = ptr;
MenuPopupSelected();
}
break;
}
}*/
}
}
if(result && isMenuBar && pressed)
result = false;
}
// Interim menus: the slaves are the ones with the focus
if(result && INTERIM_MENU)
{
Window master = this.master;
if(eClass_IsDerived(master._class, _class))
{
if(!master.OnKeyHit(key, ch))
result = false;
}
}
}
return result;
}
bool OnLoadGraphics()
{
Font font = fontObject;
int maxW = 0, maxH = 0;
int width, height;
totalHeight = 0;
background = isMenuBar ? menuBarColor : (menu ? menu.color : popupMenuColor);
FontExtent = Display::FontExtent;
if(menu)
{
ItemPtr ptr;
// Default width & height for merging menus into menu bars
if(isMenuBar)
{
FontExtent(display, font, "W",1, &maxW, &maxH);
if(!guiApp.textMode)
maxH += 6;
}
for(ptr = menu.items.first; ptr; ptr = ptr.next)
{
MenuItem item = ptr.item;
if(item.placement) continue; //&& !ptr.inserted) continue;
width = 0;
height = 0;
if(!item.isDivider)
{
if(ITEM_TEXT(item))
{
FontExtent(display, font,ITEM_TEXT(item),strlen(ITEM_TEXT(item)),&width, &height);
if(strstr(ITEM_TEXT(item), "\t"))
width += 8;
}
if(item.bitmap && item.radio)
width += 20;
if(item.subMenu) width += 20;
if(!guiApp.textMode)
height += 6;
}
else
{
if(!guiApp.textMode)
height = DIVIDER_HEIGHT;
else
height = textCellH;
}
if(width > maxW) maxW = width;
if(height > maxH) maxH = height;
totalHeight += height;
if(item.bitmaps[0]) AddResource(item.bitmaps[0]);
if(item.bitmaps[1]) AddResource(item.bitmaps[1]);
if(item.bitmaps[2]) AddResource(item.bitmaps[2]);
}
maxW += menu.hasMargin ? 32 : 24;
if(menu.text)
{
FontExtent(display, font,menu.text,strlen(menu.text),&width, &height);
if(width > maxW) maxW = width;
if(height > maxH) maxH = height;
}
rw = menu.w;
rh = menu.h;
maxW += 10;
if(rw < maxW) rw = maxW;
if(rh < maxH) rh = maxH;
}
return true;
}
bool OnResizing(int * w, int * h)
{
Window master = this.master;
Window masterMenuBar = master.menuBar;
if(this != masterMenuBar)
*w = Max(*w, rw);
if(isMenuBar)
*h = Max(*h, rh + 2);
else if(menu)
*h = Max(*h, totalHeight + 2);
if(this != masterMenuBar)
{
if(!*w)
*w = 80;
if(!*h)
*h = 20;
}
return true;
}
bool OnMoving(int *x, int *y, int w, int h)
{
if(!isMenuBar)
{
Window parent = this.parent;
if(INTERIM_MENU)
{
if(*y + h > parent.clientSize.h)
{
PopupMenu master = (PopupMenu)this.master;
*y -= h;
if(eClass_IsDerived(master._class, _class))
{
if(master.isMenuBar)
*y -= master.size.h;
else
*y += h - clientSize.h + rh;
}
*y = Max(*y, 0);
}
*x = Min(*x, ((parent == guiApp.desktop && guiApp.virtualScreen.w) ? guiApp.virtualScreen.w : parent.clientSize.w) - w);
}
else if(nonClient)
{
*x = Min(*x, parent.size.w - w);
*y = Min(*y, parent.size.h - h);
}
else
{
*x = Min(*x, parent.clientSize.w - w);
*y = Min(*y, parent.clientSize.h - h);
}
if(parent == guiApp.desktop)
{
// Just in case...
*x = Max(*x, guiApp.virtualScreenPos.x);
*y = Max(*y, guiApp.virtualScreenPos.y);
}
else
{
// Just in case...
*x = Max(*x, 0);
*y = Max(*y, 0);
}
}
return true;
}
bool OnMouseMove(int mx, int my, Modifiers mods)
{
int selectedX, selectedY;
ItemPtr selected;
if(mods.isSideEffect) return true;
selected = FindSelected(mx, my, &selectedX, &selectedY);
if((!mods.isSideEffect || !this.selected) && (/*selected && */
selected != this.selected && (!selected || !ITEM_DISABLED(selected.item)) && (selected || !keyboardFocus)))
{
if(!isMenuBar || pressed)
{
bool pressed = this.pressed;
if(firstSlave) firstSlave.Destroy(0);
this.selected = selected;
if(this.selected)
{
Menu childMenu = selected.item.subMenu;
this.pressed = pressed;
if(this.selected.item.subMenu)
MenuPopupChild(selectedX, position.y + selectedY, childMenu);
if(pressed)
keyboardFocus = true;
}
}
else
this.selected = selected;
Update(null);
}
return true;
}
bool OnLeftButtonDown(int x, int y, Modifiers mods)
{
if(isMenuBar)
{
Time t = GetTime(), u = unpressedTime;
// Had to boost this to 0.1 for Windows Basic / XP theme / Remote Desktop
// Aero & Classic were fast enough for 0.01
if(GetTime() - unpressedTime < 0.1)
return true;
if(INTERIM_MENU)
{
int selectedX, selectedY;
if(!mods.isActivate && !pressed)
{
pressed = true;
keyboardFocus = true;
selected = null;
OnMouseMove(x,y, mods);
}
else
{
if(firstSlave) firstSlave.Destroy(0);
selected = FindSelected(x, y, &selectedX, &selectedY);
pressed = false;
//selected = null;
//keyboardFocus = false;
Update(null);
}
}
else
{
if(pressed)
{
pressed = false;
keyboardFocus = false;
if(firstSlave) firstSlave.Destroy(0);
Update(null);
}
else
{
pressed = true;
keyboardFocus = true;
selected = null;
OnMouseMove(x, y, mods);
}
}
}
else //if(!INTERIM_MENU) // Why was this commented out?
{
if(!(x >= 0 && y >= 0 && x < clientSize.w && y < clientSize.h))
{
MenuDestroyMasters(false);
return false;
}
}
return true;
}
bool OnRightButtonDown(int x, int y, Modifiers mods)
{
if(x >= 0 && y >= 0 && x < clientSize.w && y < clientSize.h)
{
if(isMenuBar)
{
Window master = this.master;
Window activeClient = master.activeClient;
if(activeClient.state == maximized)
activeClient.ShowSysMenu(absPosition.x + x, absPosition.y + y);
}
}
return true;
}
bool OnLeftButtonUp(int mx, int my, Modifiers mods)
{
if(mx >= 2 /*0*/ && my >= 0 && mx < clientSize.w && my < clientSize.h)
{
Menu menu = this.menu;
int y = 0;
// Button up
if(!isMenuBar && menu)
{
ItemPtr ptr;
for(ptr = menu.items.first; ptr; ptr = ptr.next)
{
MenuItem item = ptr.item;
if(item.placement) continue; //&& !ptr.inserted) continue;
if(my >= y && my < y + rh && !item.isDivider)
{
selected = ptr;
break;
}
if(guiApp.textMode)
y += textCellH;
else
y += (item.isDivider) ? DIVIDER_HEIGHT : rh;
}
Update(null);
}
if(!isMenuBar || pressed)
{
if(selected)
{
if(!selected.item.isDivider && !selected.item.subMenu)
{
if(isMenuBar)
{
pressed = false;
keyboardFocus = false;
Update(null);
}
if(MenuItemSelection(menu, selected, Key { modifiers = mods }))
return false;
}
}
else if(pressed)
{
pressed = false;
keyboardFocus = false;
if(firstSlave) firstSlave.Destroy(0);
}
}
}
return true;
}
OnRightButtonUp = OnLeftButtonUp;
bool OnLeftDoubleClick(int x, int y, Modifiers mods)
{
if(isMenuBar)
{
int selectedX, selectedY;
ItemPtr selected = FindSelected(x, y, &selectedX, &selectedY);
if(!selected)
{
Window master = this.master;
Window activeClient = master.activeClient;
// TOFIX: Fix need for a cast here...
while(activeClient && !((BorderBits)activeClient.borderStyle).fixed)
activeClient = activeClient.activeClient;
if(activeClient && activeClient.state == maximized)
activeClient.SetState(normal, false, mods);
}
}
return true;
}
bool OnMouseLeave(Modifiers mods)
{
if(!pressed && !firstSlave)
{
selected = null;
Update(null);
ReleaseCapture();
}
return true;
}
bool OnActivate(bool active, Window swap, bool * goOnWithActivation, bool direct)
{
if(!isMenuBar)
{
if(!active)
{
if(INTERIM_MENU)
{
PopupMenu master = (PopupMenu)this.master;
if(eClass_IsDerived(master._class, _class) && master.isMenuBar) // && swap != master && swap && swap.master != master)
{
{
master.unpressedTime = GetTime();
master.pressed = false;
master.selected = null;
master.keyboardFocus = false;
// master.Update(null);
// TOFIX: Redraw bug here without this...
master.master.Update(null);
}
}
Destroy(0);
}
else
{
Window master;
bool destroy = true;
if(swap)
{
for(master = swap.master; master; master = master.master)
if(this == master)
{
destroy = false;
break;
}
}
if(destroy)
{
for(master = this.master; master; master = master.master)
if(swap == master)
{
if(eClass_IsDerived(master._class, _class))
destroy = false;
break;
}
}
if(destroy)
{
if(MenuDestroyMasters(false))
return false;
}
}
return false;
}
}
// With new activation code this is not required anymore (double effect if there)
else
{
//if(!active)
{
selected = null;
unpressedTime = GetTime();
pressed = false;
altDown = false;
keyboardFocus = false;
if(firstSlave) firstSlave.Destroy(0);
Update(null);
}
}
return true;
}
public:
property Menu menu
{
set
{
delete menu;
menu = value;
if(menu)
incref menu;
if(created)
{
selected = null;
if(firstSlave) firstSlave.Destroy(0);
OnLoadGraphics();
Move(position.x, position.y, size.w, size.h);
if(!text)
{
if(interim || isMenuBar)
text = master.text;
else
text = menu.text;
}
}
}
get { return menu; }
};
property bool isMenuBar { set { isMenuBar = value; } };
property bool focus { get { return keyboardFocus; } };
};
| 30.07848 | 177 | 0.444165 |
7de98ab622858ad9120c541d01b2a1ea860473e1 | 26,566 | edn | edn | src/main/data/analysis/european_championship_italy_republic_of_ireland,_0_1_1694418.edn | happyguydev/football-graph | c2dcc61d8836c78e29353a832e4a33af6f6df37b | [
"BSD-3-Clause"
] | 87 | 2020-02-05T17:02:47.000Z | 2022-03-24T18:27:43.000Z | src/main/data/analysis/european_championship_italy_republic_of_ireland,_0_1_1694418.edn | eddwebster/football-graphs | a1b98116f5b08fd8556d34202415a240039617cd | [
"BSD-3-Clause"
] | 49 | 2020-02-05T14:53:38.000Z | 2020-05-28T23:11:17.000Z | src/main/data/analysis/european_championship_italy_republic_of_ireland,_0_1_1694418.edn | eddwebster/football-graphs | a1b98116f5b08fd8556d34202415a240039617cd | [
"BSD-3-Clause"
] | 15 | 2020-02-13T23:16:01.000Z | 2022-03-24T18:33:28.000Z | {:match-id 1694418,
:label "Italy - Republic of Ireland, 0 - 1",
:teams-info
{:3757
{:city "Roma",
:name "Italy",
:wy-id 3757,
:official-name "Italy",
:area
{:name "Italy", :id 380, :alpha-3code "ITA", :alpha-2code "IT"},
:type "national"},
:8274
{:city "Dublin",
:name "Republic of Ireland",
:wy-id 8274,
:official-name "Republic of Ireland",
:area
{:name "Ireland Republic",
:id 372,
:alpha-3code "IRL",
:alpha-2code "IE"},
:type "national"}},
:match-info
{:winner 8274,
:home-away {:home 3757, :away 8274},
:competition-id 102,
:gameweek 3,
:duration "Regular",
:season-id 9291,
:round-id 4165470,
:group-name "Group E",
:status "Played",
:venue "Stade Pierre-Mauroy",
:dateutc "2016-06-22 19:00:00",
:home-away-id {:3757 :home, :8274 :away}},
:nodes
{:3757
({:id "22566",
:pos "22566",
:short-name ("A. Florenzi"),
:current-national-team-id 3757,
:average-pos [32.255814 47.88372039794922],
:metrics
{:out-degree 20.0,
:in-degree 23.0,
:current_flow_betweenness_centrality 0.04257520747820264,
:katz-centrality 1.3290082243534598,
:degree 43.0,
:alpha-centrality 1.3290082243534598,
:betweenness-centrality 0.07268518518518519,
:local-clustering-coefficient 0.7638888888888888,
:closeness-centrality 0.43478260869565216,
:eigenvector-centrality 9.02005262818182E-6}}
{:id "21100",
:pos "21100",
:short-name ("A. Ogbonna"),
:current-national-team-id 3757,
:average-pos [19.954546 62.04545593261719],
:metrics
{:out-degree 35.0,
:in-degree 31.0,
:current_flow_betweenness_centrality 0.05258633603557,
:katz-centrality 1.4258639818291954,
:degree 66.0,
:alpha-centrality 1.4258639818291954,
:betweenness-centrality 0.0,
:local-clustering-coefficient 0.7857142857142857,
:closeness-centrality 0.3333333333333333,
:eigenvector-centrality 1.0841110840000001E-5}}
{:id "2138521384",
:pos "2138521384",
:short-name ("L. Insigne" "C. Immobile"),
:current-national-team-id 3757,
:average-pos [36.325 38.599998474121094],
:metrics
{:out-degree 20.0,
:in-degree 20.0,
:current_flow_betweenness_centrality -0.012016575086823246,
:katz-centrality 1.2801245572349287,
:degree 40.0,
:alpha-centrality 1.2801245572349287,
:betweenness-centrality 0.14190476190476192,
:local-clustering-coefficient 0.6888888888888889,
:closeness-centrality 0.5,
:eigenvector-centrality 7.396573565454546E-6}}
{:id "25439",
:pos "25439",
:short-name ("T. Motta"),
:current-national-team-id 3757,
:average-pos [48.827957 52.74193572998047],
:metrics
{:out-degree 47.0,
:in-degree 46.0,
:current_flow_betweenness_centrality -0.014382592026739765,
:katz-centrality 1.6114947106566015,
:degree 93.0,
:alpha-centrality 1.6114947106566015,
:betweenness-centrality 0.037037037037037035,
:local-clustering-coefficient 0.6666666666666666,
:closeness-centrality 0.2857142857142857,
:eigenvector-centrality 1.4368215420909093E-5}}
{:id "20458",
:pos "20458",
:short-name ("A. Barzagli"),
:current-national-team-id 3757,
:average-pos [77.57895 69.59649085998535],
:metrics
{:out-degree 30.0,
:in-degree 27.0,
:current_flow_betweenness_centrality -0.07732093479029002,
:katz-centrality 1.3625677180610576,
:degree 57.0,
:alpha-centrality 1.3625677180610576,
:betweenness-centrality 0.05308641975308641,
:local-clustering-coefficient 0.6944444444444444,
:closeness-centrality 0.5263157894736842,
:eigenvector-centrality 8.476532450909092E-6}}
{:id "21290",
:pos "21290",
:short-name ("S. Sturaro"),
:current-national-team-id 3757,
:average-pos [75.31579 42.94736862182617],
:metrics
{:out-degree 10.0,
:in-degree 9.0,
:current_flow_betweenness_centrality -0.09939744010922147,
:katz-centrality 1.1285483466487929,
:degree 19.0,
:alpha-centrality 1.1285483466487929,
:betweenness-centrality 0.037610229276895946,
:local-clustering-coefficient 0.8333333333333334,
:closeness-centrality 0.4,
:eigenvector-centrality 3.406336294545455E-6}}
{:id "20459",
:pos "20459",
:short-name ("L. Bonucci"),
:current-national-team-id 3757,
:average-pos [54.291668 63.91666793823242],
:metrics
{:out-degree 25.0,
:in-degree 23.0,
:current_flow_betweenness_centrality -0.035127500333385776,
:katz-centrality 1.325294894521968,
:degree 48.0,
:alpha-centrality 1.325294894521968,
:betweenness-centrality 0.08246913580246915,
:local-clustering-coefficient 0.6805555555555556,
:closeness-centrality 0.5,
:eigenvector-centrality 8.756898362727274E-6}}
{:id "25421",
:pos "25421",
:short-name ("S. Sirigu"),
:current-national-team-id 3757,
:average-pos [51.90625 88.8125],
:metrics
{:out-degree 17.0,
:in-degree 15.0,
:current_flow_betweenness_centrality 0.03110909099436578,
:katz-centrality 1.2039375560617558,
:degree 32.0,
:alpha-centrality 1.2039375560617558,
:betweenness-centrality 0.07802469135802469,
:local-clustering-coefficient 0.75,
:closeness-centrality 0.5,
:eigenvector-centrality 4.919266882727273E-6}}
{:id "2041820395",
:pos "2041820395",
:short-name ("M. De Sciglio" "S. El Shaarawy"),
:current-national-team-id 3757,
:average-pos [14.3404255 36.95744705200195],
:metrics
{:out-degree 22.0,
:in-degree 25.0,
:current_flow_betweenness_centrality -0.059449968708433,
:katz-centrality 1.3448546502272773,
:degree 47.0,
:alpha-centrality 1.3448546502272773,
:betweenness-centrality 0.06343915343915343,
:local-clustering-coefficient 0.6944444444444444,
:closeness-centrality 0.4,
:eigenvector-centrality 8.883902062727274E-6}}
{:id "24606121095",
:pos "24606121095",
:short-name ("M. Darmian" "F. Bernardeschi"),
:current-national-team-id 3757,
:average-pos [83.068184 44.3636360168457],
:metrics
{:out-degree 19.0,
:in-degree 25.0,
:current_flow_betweenness_centrality -0.06543896993897486,
:katz-centrality 1.3384475940255334,
:degree 44.0,
:alpha-centrality 1.3384475940255334,
:betweenness-centrality 0.03581569664902998,
:local-clustering-coefficient 0.6428571428571429,
:closeness-centrality 0.35714285714285715,
:eigenvector-centrality 8.009179544545456E-6}}
{:id "22202",
:pos "22202",
:short-name ("S. Zaza"),
:current-national-team-id 3757,
:average-pos [44.36842 43.3684196472168],
:metrics
{:out-degree 9.0,
:in-degree 10.0,
:current_flow_betweenness_centrality 0.008816862470025614,
:katz-centrality 1.13831390282676,
:degree 19.0,
:alpha-centrality 1.13831390282676,
:betweenness-centrality 0.21282186948853613,
:local-clustering-coefficient 0.8194444444444444,
:closeness-centrality 0.43478260869565216,
:eigenvector-centrality 3.5718239981818184E-6}}),
:8274
({:id "8240",
:pos "8240",
:short-name ("S. Coleman"),
:current-national-team-id 8274,
:average-pos [89.68627 48.431373596191406],
:metrics
{:out-degree 26.0,
:in-degree 25.0,
:current_flow_betweenness_centrality 0.03519632300867592,
:katz-centrality 1.3280335530250649,
:degree 51.0,
:alpha-centrality 1.3280335530250649,
:betweenness-centrality 0.022839506172839506,
:local-clustering-coefficient 0.7321428571428571,
:closeness-centrality 0.47619047619047616,
:eigenvector-centrality 1.5135326272727275E-5}}
{:id "83468624",
:pos "83468624",
:short-name ("W. Hoolahan" "J. McCarthy"),
:current-national-team-id 8274,
:average-pos [53.377357 47.8301887512207],
:metrics
{:out-degree 29.0,
:in-degree 24.0,
:current_flow_betweenness_centrality -0.04056790115817466,
:katz-centrality 1.3137704647861987,
:degree 53.0,
:alpha-centrality 1.3137704647861987,
:betweenness-centrality 0.0022222222222222222,
:local-clustering-coefficient 0.7638888888888888,
:closeness-centrality 0.45454545454545453,
:eigenvector-centrality 1.4171232545454546E-5}}
{:id "1016668603",
:pos "1016668603",
:short-name ("D. Murphy" "A. McGeady"),
:current-national-team-id 8274,
:average-pos [55.875 30.208335876464844],
:metrics
{:out-degree 11.0,
:in-degree 13.0,
:current_flow_betweenness_centrality -0.02950925763105076,
:katz-centrality 1.1688669755597256,
:degree 24.0,
:alpha-centrality 1.1688669755597256,
:betweenness-centrality 0.04982042648709315,
:local-clustering-coefficient 0.8055555555555556,
:closeness-centrality 0.5882352941176471,
:eigenvector-centrality 7.592941181818182E-6}}
{:id "62071",
:pos "62071",
:short-name ("D. Randolph"),
:current-national-team-id 8274,
:average-pos [51.157894 90.78947353363037],
:metrics
{:out-degree 6.0,
:in-degree 13.0,
:current_flow_betweenness_centrality -0.005085462548717206,
:katz-centrality 1.1680255287408383,
:degree 19.0,
:alpha-centrality 1.1680255287408383,
:betweenness-centrality 0.22843915343915341,
:local-clustering-coefficient 0.7444444444444445,
:closeness-centrality 0.6666666666666666,
:eigenvector-centrality 7.42705181818182E-6}}
{:id "8242",
:pos "8242",
:short-name ("S. Duffy"),
:current-national-team-id 8274,
:average-pos [69.62222 66.0444450378418],
:metrics
{:out-degree 22.0,
:in-degree 23.0,
:current_flow_betweenness_centrality -0.010876093960181066,
:katz-centrality 1.2989530054097598,
:degree 45.0,
:alpha-centrality 1.2989530054097598,
:betweenness-centrality 0.060834535834535845,
:local-clustering-coefficient 0.7638888888888888,
:closeness-centrality 0.45454545454545453,
:eigenvector-centrality 1.3603926727272729E-5}}
{:id "8980",
:pos "8980",
:short-name ("J. Hendrick"),
:current-national-team-id 8274,
:average-pos [59.728813 42.23728942871094],
:metrics
{:out-degree 31.0,
:in-degree 28.0,
:current_flow_betweenness_centrality 0.018828416057452172,
:katz-centrality 1.362952546606065,
:degree 59.0,
:alpha-centrality 1.362952546606065,
:betweenness-centrality 0.05814814814814815,
:local-clustering-coefficient 0.6888888888888889,
:closeness-centrality 0.5555555555555556,
:eigenvector-centrality 1.607517009090909E-5}}
{:id "8433",
:pos "8433",
:short-name ("S. Ward"),
:current-national-team-id 8274,
:average-pos [11.086206 42.482757568359375],
:metrics
{:out-degree 28.0,
:in-degree 30.0,
:current_flow_betweenness_centrality 0.009589446960043664,
:katz-centrality 1.3829956729815451,
:degree 58.0,
:alpha-centrality 1.3829956729815451,
:betweenness-centrality 0.09432659932659931,
:local-clustering-coefficient 0.7,
:closeness-centrality 0.5263157894736842,
:eigenvector-centrality 1.6117176363636367E-5}}
{:id "8764",
:pos "8764",
:short-name ("R. Keogh"),
:current-national-team-id 8274,
:average-pos [31.75 60.86111068725586],
:metrics
{:out-degree 20.0,
:in-degree 16.0,
:current_flow_betweenness_centrality 0.043368463629372654,
:katz-centrality 1.2129351413878557,
:degree 36.0,
:alpha-centrality 1.2129351413878557,
:betweenness-centrality 0.002777777777777778,
:local-clustering-coefficient 0.8333333333333334,
:closeness-centrality 0.35714285714285715,
:eigenvector-centrality 1.0017471363636365E-5}}
{:id "9623",
:pos "9623",
:short-name ("R. Brady"),
:current-national-team-id 8274,
:average-pos [32.685184 37.796295166015625],
:metrics
{:out-degree 26.0,
:in-degree 28.0,
:current_flow_betweenness_centrality 0.04993927486802531,
:katz-centrality 1.3547775811875216,
:degree 54.0,
:alpha-centrality 1.3547775811875216,
:betweenness-centrality 0.06422558922558923,
:local-clustering-coefficient 0.6777777777777778,
:closeness-centrality 0.5555555555555556,
:eigenvector-centrality 1.4460591000000002E-5}}
{:id "86588384",
:pos "86588384",
:short-name ("S. Long" "S. Quinn"),
:current-national-team-id 8274,
:average-pos [61.076923 27.53845977783203],
:metrics
{:out-degree 7.0,
:in-degree 6.0,
:current_flow_betweenness_centrality -0.031627916780920015,
:katz-centrality 1.079394945333554,
:degree 13.0,
:alpha-centrality 1.079394945333554,
:betweenness-centrality 0.02841309924643258,
:local-clustering-coefficient 0.7666666666666667,
:closeness-centrality 0.5263157894736842,
:eigenvector-centrality 3.7192732727272732E-6}}
{:id "8530",
:pos "8530",
:short-name ("J. McClean"),
:current-national-team-id 8274,
:average-pos [21.066668 32.93333435058594],
:metrics
{:out-degree 15.0,
:in-degree 15.0,
:current_flow_betweenness_centrality -0.08643337702788181,
:katz-centrality 1.2000891032762206,
:degree 30.0,
:alpha-centrality 1.2000891032762206,
:betweenness-centrality 0.09275212441879109,
:local-clustering-coefficient 0.7321428571428571,
:closeness-centrality 0.47619047619047616,
:eigenvector-centrality 9.239296545454544E-6}})},
:links
{:3757
({:source "20458", :target "2138521384", :team-id 3757, :value 1}
{:source "25421", :target "22566", :team-id 3757, :value 1}
{:source "20459", :target "22202", :team-id 3757, :value 1}
{:source "20458", :target "22566", :team-id 3757, :value 1}
{:source "25421", :target "2138521384", :team-id 3757, :value 1}
{:source "2138521384",
:target "2041820395",
:team-id 3757,
:value 1}
{:source "25421", :target "22202", :team-id 3757, :value 1}
{:source "2041820395",
:target "24606121095",
:team-id 3757,
:value 1}
{:source "21290", :target "25439", :team-id 3757, :value 1}
{:source "22202", :target "22566", :team-id 3757, :value 1}
{:source "20459", :target "2138521384", :team-id 3757, :value 1}
{:source "2138521384", :target "20459", :team-id 3757, :value 1}
{:source "2041820395", :target "25421", :team-id 3757, :value 1}
{:source "2138521384", :target "25421", :team-id 3757, :value 1}
{:source "22566", :target "22202", :team-id 3757, :value 1}
{:source "24606121095", :target "22202", :team-id 3757, :value 1}
{:source "21290", :target "20459", :team-id 3757, :value 1}
{:source "22202", :target "24606121095", :team-id 3757, :value 1}
{:source "20459", :target "25421", :team-id 3757, :value 1}
{:source "22202", :target "2041820395", :team-id 3757, :value 1}
{:source "22566", :target "25421", :team-id 3757, :value 1}
{:source "20458", :target "21100", :team-id 3757, :value 1}
{:source "2138521384", :target "21290", :team-id 3757, :value 1}
{:source "25421", :target "20459", :team-id 3757, :value 1}
{:source "2041820395", :target "20459", :team-id 3757, :value 1}
{:source "20459", :target "22566", :team-id 3757, :value 1}
{:source "25439", :target "22202", :team-id 3757, :value 2}
{:source "2138521384", :target "22202", :team-id 3757, :value 2}
{:source "21100", :target "25421", :team-id 3757, :value 2}
{:source "20458", :target "21290", :team-id 3757, :value 2}
{:source "22566", :target "20459", :team-id 3757, :value 2}
{:source "2138521384",
:target "24606121095",
:team-id 3757,
:value 2}
{:source "20459", :target "2041820395", :team-id 3757, :value 2}
{:source "21100", :target "20458", :team-id 3757, :value 2}
{:source "22202", :target "20458", :team-id 3757, :value 2}
{:source "24606121095",
:target "2041820395",
:team-id 3757,
:value 2}
{:source "22566", :target "2138521384", :team-id 3757, :value 2}
{:source "21100", :target "22202", :team-id 3757, :value 2}
{:source "2041820395", :target "22566", :team-id 3757, :value 2}
{:source "22566", :target "24606121095", :team-id 3757, :value 2}
{:source "25421", :target "24606121095", :team-id 3757, :value 2}
{:source "2138521384", :target "25439", :team-id 3757, :value 3}
{:source "24606121095",
:target "2138521384",
:team-id 3757,
:value 3}
{:source "22566", :target "21100", :team-id 3757, :value 3}
{:source "21100", :target "22566", :team-id 3757, :value 3}
{:source "24606121095", :target "21290", :team-id 3757, :value 3}
{:source "25439", :target "21290", :team-id 3757, :value 3}
{:source "21290", :target "2041820395", :team-id 3757, :value 3}
{:source "21100", :target "2138521384", :team-id 3757, :value 3}
{:source "25439", :target "2138521384", :team-id 3757, :value 4}
{:source "20458", :target "20459", :team-id 3757, :value 4}
{:source "2138521384", :target "21100", :team-id 3757, :value 4}
{:source "22566", :target "2041820395", :team-id 3757, :value 4}
{:source "22202", :target "25439", :team-id 3757, :value 4}
{:source "25421", :target "21100", :team-id 3757, :value 4}
{:source "2041820395",
:target "2138521384",
:team-id 3757,
:value 5}
{:source "22566", :target "25439", :team-id 3757, :value 5}
{:source "25439", :target "20458", :team-id 3757, :value 5}
{:source "25439", :target "20459", :team-id 3757, :value 5}
{:source "24606121095", :target "20458", :team-id 3757, :value 5}
{:source "24606121095", :target "25439", :team-id 3757, :value 5}
{:source "21290", :target "24606121095", :team-id 3757, :value 5}
{:source "2138521384", :target "22566", :team-id 3757, :value 5}
{:source "25439", :target "2041820395", :team-id 3757, :value 5}
{:source "20458", :target "24606121095", :team-id 3757, :value 5}
{:source "2041820395", :target "25439", :team-id 3757, :value 6}
{:source "20459", :target "21100", :team-id 3757, :value 6}
{:source "2041820395", :target "21100", :team-id 3757, :value 6}
{:source "20459", :target "20458", :team-id 3757, :value 6}
{:source "25421", :target "20458", :team-id 3757, :value 7}
{:source "20458", :target "25439", :team-id 3757, :value 7}
{:source "20459", :target "25439", :team-id 3757, :value 7}
{:source "25439", :target "21100", :team-id 3757, :value 7}
{:source "25439", :target "24606121095", :team-id 3757, :value 7}
{:source "21100", :target "2041820395", :team-id 3757, :value 7}
{:source "21100", :target "25439", :team-id 3757, :value 8}
{:source "21100", :target "20459", :team-id 3757, :value 8}
{:source "25439", :target "22566", :team-id 3757, :value 9}
{:source "20458", :target "25421", :team-id 3757, :value 9}),
:8274
({:source "8433", :target "1016668603", :team-id 8274, :value 1}
{:source "62071", :target "9623", :team-id 8274, :value 1}
{:source "8980", :target "62071", :team-id 8274, :value 1}
{:source "8980", :target "8764", :team-id 8274, :value 1}
{:source "8530", :target "8980", :team-id 8274, :value 1}
{:source "1016668603", :target "8433", :team-id 8274, :value 1}
{:source "62071", :target "8242", :team-id 8274, :value 1}
{:source "83468624", :target "62071", :team-id 8274, :value 1}
{:source "86588384", :target "8433", :team-id 8274, :value 1}
{:source "8980", :target "8530", :team-id 8274, :value 1}
{:source "8242", :target "8530", :team-id 8274, :value 1}
{:source "9623", :target "62071", :team-id 8274, :value 1}
{:source "62071", :target "8764", :team-id 8274, :value 1}
{:source "9623", :target "8242", :team-id 8274, :value 1}
{:source "62071", :target "8530", :team-id 8274, :value 1}
{:source "62071", :target "86588384", :team-id 8274, :value 1}
{:source "8530", :target "8242", :team-id 8274, :value 1}
{:source "8240", :target "9623", :team-id 8274, :value 1}
{:source "8433", :target "8242", :team-id 8274, :value 1}
{:source "1016668603", :target "8242", :team-id 8274, :value 1}
{:source "8240", :target "86588384", :team-id 8274, :value 1}
{:source "1016668603", :target "62071", :team-id 8274, :value 1}
{:source "8433", :target "62071", :team-id 8274, :value 1}
{:source "1016668603", :target "8240", :team-id 8274, :value 1}
{:source "9623", :target "1016668603", :team-id 8274, :value 1}
{:source "9623", :target "86588384", :team-id 8274, :value 1}
{:source "62071", :target "8240", :team-id 8274, :value 1}
{:source "8242", :target "8433", :team-id 8274, :value 1}
{:source "86588384", :target "8240", :team-id 8274, :value 1}
{:source "86588384", :target "8530", :team-id 8274, :value 1}
{:source "8240", :target "8433", :team-id 8274, :value 1}
{:source "8530", :target "1016668603", :team-id 8274, :value 2}
{:source "86588384", :target "8980", :team-id 8274, :value 2}
{:source "86588384", :target "9623", :team-id 8274, :value 2}
{:source "8242", :target "8764", :team-id 8274, :value 2}
{:source "8980", :target "1016668603", :team-id 8274, :value 2}
{:source "8530", :target "83468624", :team-id 8274, :value 2}
{:source "8764", :target "1016668603", :team-id 8274, :value 2}
{:source "8240", :target "1016668603", :team-id 8274, :value 2}
{:source "8764", :target "62071", :team-id 8274, :value 2}
{:source "8980", :target "83468624", :team-id 8274, :value 2}
{:source "8764", :target "83468624", :team-id 8274, :value 2}
{:source "83468624", :target "9623", :team-id 8274, :value 2}
{:source "9623", :target "8240", :team-id 8274, :value 2}
{:source "1016668603", :target "83468624", :team-id 8274, :value 2}
{:source "8530", :target "9623", :team-id 8274, :value 3}
{:source "8764", :target "8242", :team-id 8274, :value 3}
{:source "9623", :target "8764", :team-id 8274, :value 3}
{:source "83468624", :target "8242", :team-id 8274, :value 3}
{:source "8242", :target "83468624", :team-id 8274, :value 3}
{:source "8242", :target "8980", :team-id 8274, :value 3}
{:source "8980", :target "86588384", :team-id 8274, :value 3}
{:source "83468624", :target "1016668603", :team-id 8274, :value 3}
{:source "83468624", :target "8980", :team-id 8274, :value 3}
{:source "8980", :target "8433", :team-id 8274, :value 3}
{:source "8980", :target "8242", :team-id 8274, :value 3}
{:source "8764", :target "9623", :team-id 8274, :value 3}
{:source "8433", :target "8764", :team-id 8274, :value 4}
{:source "9623", :target "8530", :team-id 8274, :value 4}
{:source "8764", :target "8433", :team-id 8274, :value 4}
{:source "9623", :target "83468624", :team-id 8274, :value 4}
{:source "9623", :target "8980", :team-id 8274, :value 4}
{:source "8764", :target "8980", :team-id 8274, :value 4}
{:source "83468624", :target "8240", :team-id 8274, :value 4}
{:source "8433", :target "8980", :team-id 8274, :value 4}
{:source "8433", :target "83468624", :team-id 8274, :value 4}
{:source "83468624", :target "8764", :team-id 8274, :value 5}
{:source "1016668603", :target "9623", :team-id 8274, :value 5}
{:source "8980", :target "9623", :team-id 8274, :value 5}
{:source "8240", :target "83468624", :team-id 8274, :value 5}
{:source "9623", :target "8433", :team-id 8274, :value 5}
{:source "8242", :target "62071", :team-id 8274, :value 6}
{:source "8242", :target "8240", :team-id 8274, :value 6}
{:source "8530", :target "8433", :team-id 8274, :value 6}
{:source "8433", :target "9623", :team-id 8274, :value 6}
{:source "8240", :target "8980", :team-id 8274, :value 7}
{:source "8433", :target "8530", :team-id 8274, :value 7}
{:source "83468624", :target "8433", :team-id 8274, :value 8}
{:source "8240", :target "8242", :team-id 8274, :value 9}
{:source "8980", :target "8240", :team-id 8274, :value 10})},
:stats
{:global
{:out-degree {:min 6.0, :max 47.0},
:passes {:min 1, :max 10},
:in-degree {:min 6.0, :max 46.0},
:current_flow_betweenness_centrality
{:min -0.09939744010922147, :max 0.05258633603557},
:katz-centrality {:min 1.079394945333554, :max 1.6114947106566015},
:degree {:min 13.0, :max 93.0},
:alpha-centrality {:min 1.079394945333554, :max 1.6114947106566015},
:betweenness-centrality {:min 0.0, :max 0.22843915343915341},
:local-clustering-coefficient
{:min 0.6428571428571429, :max 0.8333333333333334},
:closeness-centrality
{:min 0.2857142857142857, :max 0.6666666666666666},
:eigenvector-centrality
{:min 3.406336294545455E-6, :max 1.6117176363636367E-5}},
:home
{:out-degree {:min 9.0, :max 47.0},
:average-clustering-coefficient 0.7291125541125542,
:algebraic-connectivity 17.810455114249017,
:global-clustering-coefficient 0.85,
:average-node-connectivity 6.318181818181818,
:passes {:min 1, :max 9},
:in-degree {:min 9.0, :max 46.0},
:current_flow_betweenness_centrality
{:min -0.09939744010922147, :max 0.05258633603557},
:katz-centrality {:min 1.1285483466487929, :max 1.6114947106566015},
:degree {:min 19.0, :max 93.0},
:alpha-centrality
{:min 1.1285483466487929, :max 1.6114947106566015},
:betweenness-centrality {:min 0.0, :max 0.21282186948853613},
:local-clustering-coefficient
{:min 0.6428571428571429, :max 0.8333333333333334},
:closeness-centrality
{:min 0.2857142857142857, :max 0.5263157894736842},
:eigenvector-centrality
{:min 3.406336294545455E-6, :max 1.4368215420909093E-5}},
:away
{:out-degree {:min 6.0, :max 31.0},
:average-clustering-coefficient 0.7462481962481963,
:algebraic-connectivity 13.52867966212796,
:global-clustering-coefficient 0.8842105263157894,
:average-node-connectivity 6.318181818181818,
:passes {:min 1, :max 10},
:in-degree {:min 6.0, :max 30.0},
:current_flow_betweenness_centrality
{:min -0.08643337702788181, :max 0.04993927486802531},
:katz-centrality {:min 1.079394945333554, :max 1.3829956729815451},
:degree {:min 13.0, :max 59.0},
:alpha-centrality {:min 1.079394945333554, :max 1.3829956729815451},
:betweenness-centrality
{:min 0.0022222222222222222, :max 0.22843915343915341},
:local-clustering-coefficient
{:min 0.6777777777777778, :max 0.8333333333333334},
:closeness-centrality
{:min 0.35714285714285715, :max 0.6666666666666666},
:eigenvector-centrality
{:min 3.7192732727272732E-6, :max 1.6117176363636367E-5}}}}
| 42.168254 | 71 | 0.658172 |
a8cce99425fa1319bd79055c33c7aa388312f123 | 411 | edn | edn | edn/cards/ApexPublicPredator.edn | MNeMoNiCuZ/netrunner-data | 15ded7a321a3b73fe60a1e45744fbd9881d4fd86 | [
"MIT"
] | null | null | null | edn/cards/ApexPublicPredator.edn | MNeMoNiCuZ/netrunner-data | 15ded7a321a3b73fe60a1e45744fbd9881d4fd86 | [
"MIT"
] | null | null | null | edn/cards/ApexPublicPredator.edn | MNeMoNiCuZ/netrunner-data | 15ded7a321a3b73fe60a1e45744fbd9881d4fd86 | [
"MIT"
] | 1 | 2020-09-16T01:28:05.000Z | 2020-09-16T01:28:05.000Z | {:base-link 0
:deck-limit 1
:faction :apex
:id "ApexPublicPredator"
:influence-limit 25
:minimum-deck-size 45
:side :runner
:subtype [:digital]
:text "You cannot install non-<strong>virtual</strong> resources.\nPlay with the top card of the stack faceup.\nWhen your turn begins, you may install the top card of the stack facedown."
:title "Apex : Public Predator"
:type :identity
:uniqueness false}
| 31.615385 | 188 | 0.737226 |
139bc34cdd141a1f192719c37181708c67ebce8d | 437 | edn | edn | edn/cards/weir.edn | plural/netrunner-data | b71186e109a77a737c1f597b59b0ae0a64c2ab0f | [
"MIT"
] | 7 | 2018-11-21T13:36:52.000Z | 2022-03-12T21:02:50.000Z | edn/cards/weir.edn | plural/netrunner-data | b71186e109a77a737c1f597b59b0ae0a64c2ab0f | [
"MIT"
] | 4 | 2019-02-21T00:42:00.000Z | 2021-02-20T22:31:54.000Z | edn/cards/weir.edn | plural/netrunner-data | b71186e109a77a737c1f597b59b0ae0a64c2ab0f | [
"MIT"
] | 9 | 2019-01-22T21:16:45.000Z | 2021-08-02T14:55:56.000Z | {:cost 3
:deck-limit 3
:faction :neutral-corp
:id "weir"
:influence-cost 0
:side :corp
:strength 3
:stripped-text "Subroutine The Runner loses click, if able Subroutine The Runner trashes 1 card from his or her grip."
:stripped-title "Weir"
:subtype [:code-gate]
:text "[subroutine] The Runner loses [click], if able\n[subroutine] The Runner trashes 1 card from his or her grip."
:title "Weir"
:type :ice
:uniqueness false}
| 29.133333 | 119 | 0.718535 |
832c022438a8f1df8e94918b7919a7238ccf7fde | 646 | edn | edn | edn/cards/launch-campaign.edn | plural/netrunner-data | b71186e109a77a737c1f597b59b0ae0a64c2ab0f | [
"MIT"
] | 7 | 2018-11-21T13:36:52.000Z | 2022-03-12T21:02:50.000Z | edn/cards/launch-campaign.edn | plural/netrunner-data | b71186e109a77a737c1f597b59b0ae0a64c2ab0f | [
"MIT"
] | 4 | 2019-02-21T00:42:00.000Z | 2021-02-20T22:31:54.000Z | edn/cards/launch-campaign.edn | plural/netrunner-data | b71186e109a77a737c1f597b59b0ae0a64c2ab0f | [
"MIT"
] | 9 | 2019-01-22T21:16:45.000Z | 2021-08-02T14:55:56.000Z | {:cost 1
:deck-limit 3
:faction :neutral-corp
:id "launch-campaign"
:influence-cost 0
:side :corp
:stripped-text "Place 6 credits from the bank on Launch Campaign when it is rezzed. When there are no credits left on Launch Campaign, trash it. When your turn begins, take 2 credits from Launch Campaign."
:stripped-title "Launch Campaign"
:subtype [:advertisement]
:text "Place 6[credit] from the bank on Launch Campaign when it is rezzed. When there are no credits left on Launch Campaign, trash it.\nWhen your turn begins, take 2[credit] from Launch Campaign."
:title "Launch Campaign"
:trash-cost 2
:type :asset
:uniqueness false}
| 43.066667 | 206 | 0.752322 |
310ec772dfc6880e183e2eb0f9dbc7ef9715f84d | 908 | edn | edn | data/cards/project-kusanagi.edn | ChooJeremy/netrunner | b65d1c6dc893300a6e584ebdca9e57ea1cf16c23 | [
"MIT"
] | null | null | null | data/cards/project-kusanagi.edn | ChooJeremy/netrunner | b65d1c6dc893300a6e584ebdca9e57ea1cf16c23 | [
"MIT"
] | null | null | null | data/cards/project-kusanagi.edn | ChooJeremy/netrunner | b65d1c6dc893300a6e584ebdca9e57ea1cf16c23 | [
"MIT"
] | null | null | null | {:advancementcost 2,
:agendapoints 0,
:code "11052",
:cycle_code "flashpoint",
:deck-limit 3,
:faction "Jinteki",
:format {:classic :legal,
:core-experience :rotated,
:eternal :legal,
:snapshot :legal,
:snapshot-plus :legal,
:socr8 :rotated,
:standard :legal},
:image_url "http://www.cardgamedb.com/forums/uploads/an/med_ADN38_52.png",
:normalizedtitle "project-kusanagi",
:number 52,
:quantity 3,
:rotated false,
:set_code "es",
:setname "Escalation",
:side "Corp",
:subtype "Security",
:text "When you score Project Kusanagi, place 1 agenda counter on it for each advancement token on it over 2.\n<strong>Hosted agenda counter:</strong> Choose 1 piece of ice to gain \"[subroutine] Do 1 net damage.\" after all its other subroutines for the remainder of this run.",
:title "Project Kusanagi",
:type "Agenda",
:uniqueness false} | 34.923077 | 280 | 0.677313 |
b507820dfb62f009f727ccac136757540ac86ef1 | 913 | edn | edn | resources/tests/1045ac0581bcbc22f1328d2cd6002b7d.edn | Tshort76/pdf-parse | e61c82943381fb32dae292c447d787c431ed9c28 | [
"MIT"
] | 1 | 2021-09-20T17:11:29.000Z | 2021-09-20T17:11:29.000Z | resources/tests/1045ac0581bcbc22f1328d2cd6002b7d.edn | Tshort76/pdf-parse | e61c82943381fb32dae292c447d787c431ed9c28 | [
"MIT"
] | null | null | null | resources/tests/1045ac0581bcbc22f1328d2cd6002b7d.edn | Tshort76/pdf-parse | e61c82943381fb32dae292c447d787c431ed9c28 | [
"MIT"
] | null | null | null | {:tables [{:type :table, :vals [["Year" "Amount($)"] ["2038" "23,750,000"] ["2039" "24,995,000"] ["2040" "26,310,000"] ["2041" "27,695,000"] ["2042 †" "29,140,000"]], :y0 55, :y1 125, :x0 256, :x1 350, :page-number 1} {:type :table, :vals [["Year" "Amount($)"] ["2043" "30,680,000"] ["2044" "32,210,000"] ["2045" "33,820,000"] ["2046" "35,505,000"] ["2047 †" "37,290,000"] ["† Final Maturity" ""]], :y0 210, :y1 293, :x0 256, :x1 350, :page-number 1} {:type :table, :vals [["Year" "Amount($)"] ["2048" "39,150,000"] ["2049" "41,105,000"] ["2050" "43,165,000"] ["2051" "45,320,000"] ["2052 †" "47,585,000"] ["† Final Maturity" ""]], :y0 366, :y1 449, :x0 256, :x1 350, :page-number 1} {:type :table, :vals [["Year" "Amount($)"] ["2038" "4,705,000"] ["2039" "4,905,000"] ["2040" "5,110,000"] ["2041" "5,330,000"] ["2042 †" "5,555,000"] ["† Final Maturity" ""]], :y0 534, :y1 617, :x0 256, :x1 347, :page-number 1}]} | 913 | 913 | 0.542169 |
0f8b25ccfd9c80aefea40f69399f90ce801f133f | 114 | edn | edn | .clj-kondo/metosin/malli/config.edn | jaszczur/reitit-hello | 011c03a65d124cdbf41d7aa48528f5fef87ad9c6 | [
"MIT"
] | 1 | 2022-02-03T00:56:47.000Z | 2022-02-03T00:56:47.000Z | .clj-kondo/metosin/malli/config.edn | sultanov-team/metaverse | 8530a841143af823138f78e782ef92c59c24f66c | [
"MIT"
] | null | null | null | .clj-kondo/metosin/malli/config.edn | sultanov-team/metaverse | 8530a841143af823138f78e782ef92c59c24f66c | [
"MIT"
] | null | null | null | {:lint-as {malli.experimental/defn schema.core/defn}
:linters {:unresolved-symbol {:exclude [(malli.core/=>)]}}}
| 38 | 60 | 0.701754 |
650d2640c7fc3ee2a491c3e5e45d816db2f80cff | 122 | edn | edn | core/resources/rgl/paradigms/lav/AV.edn | Site-Command/accelerated-text | fe49cc2806e25189e81cbda4328728775026856b | [
"Apache-2.0"
] | 400 | 2019-09-28T13:35:13.000Z | 2021-11-23T01:53:51.000Z | api/resources/paradigms/lav/AV.edn | anantasty/accelerated-text | 16f3d7e05306c5b1c04fb95546051cc1e2570893 | [
"Apache-2.0"
] | 87 | 2019-10-16T09:50:14.000Z | 2021-09-22T14:02:15.000Z | api/resources/paradigms/lav/AV.edn | anantasty/accelerated-text | 16f3d7e05306c5b1c04fb95546051cc1e2570893 | [
"Apache-2.0"
] | 32 | 2019-09-30T16:45:06.000Z | 2021-08-25T07:44:37.000Z | {:type "AV",
:description "",
:module "ParadigmsLav",
:functions [{:function "mkAV", :type ["A" "AV"], :example "-"}]}
| 24.4 | 65 | 0.57377 |
422f61c06c6cc5f6970545018c3101221ad62892 | 491 | edn | edn | data/cards/gpi-net-tap.edn | poi2000/netrunner | b08c26fc0e578d6535518f197867083bb1627e80 | [
"MIT"
] | null | null | null | data/cards/gpi-net-tap.edn | poi2000/netrunner | b08c26fc0e578d6535518f197867083bb1627e80 | [
"MIT"
] | null | null | null | data/cards/gpi-net-tap.edn | poi2000/netrunner | b08c26fc0e578d6535518f197867083bb1627e80 | [
"MIT"
] | null | null | null | {:code "11003",
:cost 3,
:cycle_code "flashpoint",
:faction "Criminal",
:factioncost 2,
:image_url "http://www.cardgamedb.com/forums/uploads/an/med_ADN36_3.png",
:limited 3,
:normalizedtitle "gpi-net-tap",
:number 3,
:packquantity 3,
:rotated false,
:set_code "23s",
:setname "23 Seconds",
:side "Runner",
:text "Whenever you approach a piece of ice, you may expose it. You may then trash GPI Net Tap to jack out.",
:title "GPI Net Tap",
:type "Hardware",
:uniqueness false} | 27.277778 | 110 | 0.696538 |
42058b25615d0a1a361a8104e3fa107651db775c | 28,363 | edn | edn | src/main/data/analysis/france_metz_saint_etienne,_3_0_2500892.edn | happyguydev/football-graph | c2dcc61d8836c78e29353a832e4a33af6f6df37b | [
"BSD-3-Clause"
] | 87 | 2020-02-05T17:02:47.000Z | 2022-03-24T18:27:43.000Z | src/main/data/analysis/france_metz_saint_etienne,_3_0_2500892.edn | eddwebster/football-graphs | a1b98116f5b08fd8556d34202415a240039617cd | [
"BSD-3-Clause"
] | 49 | 2020-02-05T14:53:38.000Z | 2020-05-28T23:11:17.000Z | src/main/data/analysis/france_metz_saint_etienne,_3_0_2500892.edn | eddwebster/football-graphs | a1b98116f5b08fd8556d34202415a240039617cd | [
"BSD-3-Clause"
] | 15 | 2020-02-13T23:16:01.000Z | 2022-03-24T18:33:28.000Z | {:match-id 2500892,
:label "Metz - Saint-\\u00c9tienne, 3 - 0",
:teams-info
{:3777
{:city "Metz",
:name "Metz",
:wy-id 3777,
:official-name "FC Metz",
:area
{:name "France", :id "250", :alpha-3code "FRA", :alpha-2code "FR"},
:type "club"},
:3782
{:city "Saint-\\u00c9tienne",
:name "Saint-\\u00c9tienne",
:wy-id 3782,
:official-name "AS Saint-\\u00c9tienne",
:area
{:name "France", :id "250", :alpha-3code "FRA", :alpha-2code "FR"},
:type "club"}},
:match-info
{:winner 3777,
:home-away {:home 3777, :away 3782},
:competition-id 412,
:gameweek 21,
:duration "Regular",
:season-id 181189,
:round-id 4405655,
:group-name nil,
:status "Played",
:venue "Stade Saint-Symphorien",
:dateutc "2018-01-17 18:00:00",
:home-away-id {:3777 :home, :3782 :away}},
:nodes
{:3777
({:id "290119",
:pos "290119",
:short-name ("M. Niakhaté"),
:current-national-team-id 3777,
:average-pos [21.333334 61.52381134033203],
:metrics
{:out-degree 22.0,
:in-degree 20.0,
:current_flow_betweenness_centrality 0.0029819707009888477,
:katz-centrality 1.2592916781140937,
:degree 42.0,
:alpha-centrality 1.2592916781140937,
:betweenness-centrality 0.19669312169312164,
:local-clustering-coefficient 0.7333333333333333,
:closeness-centrality 0.5,
:eigenvector-centrality 4.2480793381818176E-6}}
{:id "8648625503",
:pos "8648625503",
:short-name ("G. Poblete" "G. Mandjeck"),
:current-national-team-id 3777,
:average-pos [31.66154 50.07692337036133],
:metrics
{:out-degree 32.0,
:in-degree 33.0,
:current_flow_betweenness_centrality 0.019730171175470247,
:katz-centrality 1.430408662495778,
:degree 65.0,
:alpha-centrality 1.430408662495778,
:betweenness-centrality 0.035151515151515156,
:local-clustering-coefficient 0.7222222222222222,
:closeness-centrality 0.4,
:eigenvector-centrality 7.370404425454546E-6}}
{:id "25716",
:pos "25716",
:short-name ("N. Roux"),
:current-national-team-id 3777,
:average-pos [25.558823 40.29411697387695],
:metrics
{:out-degree 17.0,
:in-degree 17.0,
:current_flow_betweenness_centrality -0.07782347255070875,
:katz-centrality 1.2283479553153727,
:degree 34.0,
:alpha-centrality 1.2283479553153727,
:betweenness-centrality 0.08743386243386243,
:local-clustering-coefficient 0.7638888888888888,
:closeness-centrality 0.5882352941176471,
:eigenvector-centrality 4.235083249090909E-6}}
{:id "37896",
:pos "37896",
:short-name ("E. Kawashima"),
:current-national-team-id 3777,
:average-pos [54.833332 87.11111068725586],
:metrics
{:out-degree 10.0,
:in-degree 8.0,
:current_flow_betweenness_centrality -0.028315138149903243,
:katz-centrality 1.1006381504458114,
:degree 18.0,
:alpha-centrality 1.1006381504458114,
:betweenness-centrality 0.16026936026936026,
:local-clustering-coefficient 0.8035714285714286,
:closeness-centrality 0.5882352941176471,
:eigenvector-centrality 1.510837280909091E-6}}
{:id "26512",
:pos "26512",
:short-name ("M. Dossevi"),
:current-national-team-id 3777,
:average-pos [75.82 36.13999938964844],
:metrics
{:out-degree 24.0,
:in-degree 26.0,
:current_flow_betweenness_centrality -0.08832920423902048,
:katz-centrality 1.3593663675522056,
:degree 50.0,
:alpha-centrality 1.3593663675522056,
:betweenness-centrality 0.01825396825396825,
:local-clustering-coefficient 0.8194444444444444,
:closeness-centrality 0.38461538461538464,
:eigenvector-centrality 7.164933356363637E-6}}
{:id "26138",
:pos "26138",
:short-name ("J. Rivierez"),
:current-national-team-id 3777,
:average-pos [74.690475 57.16666793823242],
:metrics
{:out-degree 23.0,
:in-degree 19.0,
:current_flow_betweenness_centrality -0.03411304734665017,
:katz-centrality 1.2631112826763056,
:degree 42.0,
:alpha-centrality 1.2631112826763056,
:betweenness-centrality 0.09925204425204423,
:local-clustering-coefficient 0.8055555555555556,
:closeness-centrality 0.5882352941176471,
:eigenvector-centrality 5.279442695454545E-6}}
{:id "26508",
:pos "26508",
:short-name ("R. Cohade"),
:current-national-team-id 3777,
:average-pos [55.644737 46.25],
:metrics
{:out-degree 34.0,
:in-degree 42.0,
:current_flow_betweenness_centrality 0.054487530167942805,
:katz-centrality 1.5587935014979057,
:degree 76.0,
:alpha-centrality 1.5587935014979057,
:betweenness-centrality 0.018518518518518517,
:local-clustering-coefficient 0.7638888888888888,
:closeness-centrality 0.43478260869565216,
:eigenvector-centrality 1.0122596532727273E-5}}
{:id "25809498357",
:pos "25809498357",
:short-name ("I. Niane" "E. Rivière"),
:current-national-team-id 3777,
:average-pos [42.045456 31.31818389892578],
:metrics
{:out-degree 21.0,
:in-degree 23.0,
:current_flow_betweenness_centrality -0.034505051120980686,
:katz-centrality 1.3102482870671373,
:degree 44.0,
:alpha-centrality 1.3102482870671373,
:betweenness-centrality 0.023383838383838382,
:local-clustering-coefficient 0.7666666666666667,
:closeness-centrality 0.37037037037037035,
:eigenvector-centrality 5.776102814545454E-6}}
{:id "14990",
:pos "14990",
:short-name ("F. Diagne"),
:current-national-team-id 3777,
:average-pos [53.375 66.67499923706055],
:metrics
{:out-degree 26.0,
:in-degree 14.0,
:current_flow_betweenness_centrality -0.045183942371175706,
:katz-centrality 1.1853101039605771,
:degree 40.0,
:alpha-centrality 1.1853101039605771,
:betweenness-centrality 0.056500721500721496,
:local-clustering-coefficient 0.7638888888888888,
:closeness-centrality 0.35714285714285715,
:eigenvector-centrality 3.178394739090909E-6}}
{:id "478637796",
:pos "478637796",
:short-name ("D. Miličević" "Iván Balliu"),
:current-national-team-id 3777,
:average-pos [37.672726 40.654544830322266],
:metrics
{:out-degree 24.0,
:in-degree 31.0,
:current_flow_betweenness_centrality 0.006342333916283375,
:katz-centrality 1.416321637682407,
:degree 55.0,
:alpha-centrality 1.416321637682407,
:betweenness-centrality 0.02685185185185185,
:local-clustering-coefficient 0.7333333333333333,
:closeness-centrality 0.5,
:eigenvector-centrality 7.765422212727273E-6}}
{:id "25919",
:pos "25919",
:short-name ("J. Palmieri"),
:current-national-team-id 3777,
:average-pos [10.76 44.68000030517578],
:metrics
{:out-degree 25.0,
:in-degree 25.0,
:current_flow_betweenness_centrality 0.011399878039980334,
:katz-centrality 1.349041804255035,
:degree 50.0,
:alpha-centrality 1.349041804255035,
:betweenness-centrality 0.011195286195286196,
:local-clustering-coefficient 0.8809523809523809,
:closeness-centrality 0.2702702702702703,
:eigenvector-centrality 6.938172776363636E-6}}),
:3782
({:id "276944",
:pos "276944",
:short-name ("J. Bamba"),
:current-national-team-id 3782,
:average-pos [56.17808 40.6301383972168],
:metrics
{:out-degree 37.0,
:in-degree 36.0,
:current_flow_betweenness_centrality -0.08662673072874412,
:katz-centrality 1.626028699185862,
:degree 73.0,
:alpha-centrality 1.626028699185862,
:betweenness-centrality 0.01170940170940171,
:local-clustering-coefficient 0.8666666666666667,
:closeness-centrality 0.2564102564102564,
:eigenvector-centrality 2.6455649958719187E-5}}
{:id "2600085438",
:pos "2600085438",
:short-name ("R. Berič" "B. Dabo"),
:current-national-team-id 3782,
:average-pos [57.89796 47.67346954345703],
:metrics
{:out-degree 22.0,
:in-degree 27.0,
:current_flow_betweenness_centrality -0.05344701851524021,
:katz-centrality 1.4671804738079333,
:degree 49.0,
:alpha-centrality 1.4671804738079333,
:betweenness-centrality 0.10205128205128204,
:local-clustering-coefficient 0.8666666666666667,
:closeness-centrality 0.47619047619047616,
:eigenvector-centrality 1.977554771206546E-5}}
{:id "25864",
:pos "25864",
:short-name ("L. Perrin"),
:current-national-team-id 3782,
:average-pos [32.126316 63.842105865478516],
:metrics
{:out-degree 52.0,
:in-degree 43.0,
:current_flow_betweenness_centrality -0.0536603444018529,
:katz-centrality 1.7051852073792637,
:degree 95.0,
:alpha-centrality 1.7051852073792637,
:betweenness-centrality 0.020923890923890923,
:local-clustering-coefficient 0.8666666666666667,
:closeness-centrality 0.29411764705882354,
:eigenvector-centrality 2.7503698072194004E-5}}
{:id "25999",
:pos "25999",
:short-name ("R. Cabella"),
:current-national-team-id 3782,
:average-pos [41.6 44.56470489501953],
:metrics
{:out-degree 40.0,
:in-degree 45.0,
:current_flow_betweenness_centrality -0.016556684990789203,
:katz-centrality 1.752067680956907,
:degree 85.0,
:alpha-centrality 1.752067680956907,
:betweenness-centrality 0.03277777777777778,
:local-clustering-coefficient 0.8555555555555555,
:closeness-centrality 0.3225806451612903,
:eigenvector-centrality 3.002800839080601E-5}}
{:id "2604225789",
:pos "2604225789",
:short-name ("K. Monnet-Paquet" "C. M'Bengue"),
:current-national-team-id 3782,
:average-pos [11.923077 48.03845977783203],
:metrics
{:out-degree 26.0,
:in-degree 26.0,
:current_flow_betweenness_centrality -0.12217397289313069,
:katz-centrality 1.4353080414899246,
:degree 52.0,
:alpha-centrality 1.4353080414899246,
:betweenness-centrality 0.03351851851851851,
:local-clustering-coefficient 0.9166666666666666,
:closeness-centrality 0.2702702702702703,
:eigenvector-centrality 1.7395650407512277E-5}}
{:id "25889",
:pos "25889",
:short-name ("R. Hamouma"),
:current-national-team-id 3782,
:average-pos [45.525 47.025001525878906],
:metrics
{:out-degree 22.0,
:in-degree 18.0,
:current_flow_betweenness_centrality -0.01759273118198765,
:katz-centrality 1.3104027337293283,
:degree 40.0,
:alpha-centrality 1.3104027337293283,
:betweenness-centrality 0.27451973951973946,
:local-clustering-coefficient 0.8666666666666667,
:closeness-centrality 0.4,
:eigenvector-centrality 1.3147640737547639E-5}}
{:id "25649134797",
:pos "25649134797",
:short-name ("Hernani" "Y. M'Vila"),
:current-national-team-id 3782,
:average-pos [45.202248 59.46067428588867],
:metrics
{:out-degree 45.0,
:in-degree 44.0,
:current_flow_betweenness_centrality 0.014887386526752576,
:katz-centrality 1.753995609094267,
:degree 89.0,
:alpha-centrality 1.753995609094267,
:betweenness-centrality 0.002442002442002442,
:local-clustering-coefficient 0.8555555555555555,
:closeness-centrality 0.2564102564102564,
:eigenvector-centrality 3.1110364551760915E-5}}
{:id "26216",
:pos "26216",
:short-name ("J. Moulin"),
:current-national-team-id 3782,
:average-pos [52.866665 88.6444444656372],
:metrics
{:out-degree 24.0,
:in-degree 21.0,
:current_flow_betweenness_centrality -0.13513518592663346,
:katz-centrality 1.3869233225751048,
:degree 45.0,
:alpha-centrality 1.3869233225751048,
:betweenness-centrality 0.0624053724053724,
:local-clustering-coefficient 0.9222222222222223,
:closeness-centrality 0.3225806451612903,
:eigenvector-centrality 1.7203051258556093E-5}}
{:id "25643",
:pos "25643",
:short-name ("K. Théophile Catherine"),
:current-national-team-id 3782,
:average-pos [73.565895 65.7984504699707],
:metrics
{:out-degree 61.0,
:in-degree 68.0,
:current_flow_betweenness_centrality 0.0022505741230604078,
:katz-centrality 2.110416319361961,
:degree 129.0,
:alpha-centrality 2.110416319361961,
:betweenness-centrality 0.0,
:local-clustering-coefficient 0.8555555555555555,
:closeness-centrality 0.2702702702702703,
:eigenvector-centrality 4.369705889159273E-5}}
{:id "364644",
:pos "364644",
:short-name ("A. Dioussé"),
:current-national-team-id 3782,
:average-pos [43.380436 60.206520080566406],
:metrics
{:out-degree 47.0,
:in-degree 45.0,
:current_flow_betweenness_centrality 0.03428734259678151,
:katz-centrality 1.7492465432167537,
:degree 92.0,
:alpha-centrality 1.7492465432167537,
:betweenness-centrality 0.01596866096866097,
:local-clustering-coefficient 0.8444444444444444,
:closeness-centrality 0.43478260869565216,
:eigenvector-centrality 2.974903760333128E-5}}
{:id "396616",
:pos "396616",
:short-name ("R. Pierre-Gabriel"),
:current-national-team-id 3782,
:average-pos [89.74627 54.31343460083008],
:metrics
{:out-degree 32.0,
:in-degree 35.0,
:current_flow_betweenness_centrality -0.10421272987196781,
:katz-centrality 1.6295707507721344,
:degree 67.0,
:alpha-centrality 1.6295707507721344,
:betweenness-centrality 0.023148148148148143,
:local-clustering-coefficient 0.9166666666666666,
:closeness-centrality 0.37037037037037035,
:eigenvector-centrality 2.763818015196028E-5}})},
:links
{:3782
({:source "25643", :target "2604225789", :team-id 3782, :value 1}
{:source "396616", :target "25864", :team-id 3782, :value 1}
{:source "25999", :target "26216", :team-id 3782, :value 1}
{:source "2600085438", :target "26216", :team-id 3782, :value 1}
{:source "396616", :target "26216", :team-id 3782, :value 1}
{:source "2600085438", :target "276944", :team-id 3782, :value 1}
{:source "26216", :target "25889", :team-id 3782, :value 1}
{:source "364644", :target "25889", :team-id 3782, :value 1}
{:source "364644", :target "26216", :team-id 3782, :value 1}
{:source "364644", :target "2600085438", :team-id 3782, :value 1}
{:source "25889", :target "25864", :team-id 3782, :value 1}
{:source "2600085438", :target "25889", :team-id 3782, :value 1}
{:source "396616", :target "25649134797", :team-id 3782, :value 1}
{:source "25864", :target "25889", :team-id 3782, :value 1}
{:source "25889", :target "2600085438", :team-id 3782, :value 2}
{:source "2604225789",
:target "2600085438",
:team-id 3782,
:value 2}
{:source "26216", :target "276944", :team-id 3782, :value 2}
{:source "25889", :target "25999", :team-id 3782, :value 2}
{:source "2600085438", :target "25864", :team-id 3782, :value 2}
{:source "276944", :target "2604225789", :team-id 3782, :value 2}
{:source "25649134797", :target "25889", :team-id 3782, :value 2}
{:source "25999", :target "25889", :team-id 3782, :value 2}
{:source "2600085438",
:target "2604225789",
:team-id 3782,
:value 2}
{:source "25889", :target "276944", :team-id 3782, :value 2}
{:source "2600085438",
:target "25649134797",
:team-id 3782,
:value 2}
{:source "396616", :target "364644", :team-id 3782, :value 2}
{:source "396616", :target "25889", :team-id 3782, :value 2}
{:source "25889", :target "25649134797", :team-id 3782, :value 2}
{:source "2604225789", :target "26216", :team-id 3782, :value 2}
{:source "2600085438", :target "364644", :team-id 3782, :value 2}
{:source "25999", :target "396616", :team-id 3782, :value 2}
{:source "2600085438", :target "396616", :team-id 3782, :value 3}
{:source "364644", :target "2604225789", :team-id 3782, :value 3}
{:source "25889", :target "364644", :team-id 3782, :value 3}
{:source "25889", :target "2604225789", :team-id 3782, :value 3}
{:source "276944", :target "25864", :team-id 3782, :value 3}
{:source "25864", :target "25649134797", :team-id 3782, :value 3}
{:source "2604225789",
:target "25649134797",
:team-id 3782,
:value 3}
{:source "25649134797", :target "396616", :team-id 3782, :value 3}
{:source "364644", :target "396616", :team-id 3782, :value 3}
{:source "25999", :target "364644", :team-id 3782, :value 3}
{:source "2600085438", :target "25999", :team-id 3782, :value 3}
{:source "25889", :target "25643", :team-id 3782, :value 3}
{:source "276944", :target "2600085438", :team-id 3782, :value 3}
{:source "25643", :target "25889", :team-id 3782, :value 3}
{:source "364644", :target "276944", :team-id 3782, :value 3}
{:source "25999", :target "25649134797", :team-id 3782, :value 3}
{:source "276944", :target "364644", :team-id 3782, :value 3}
{:source "396616", :target "276944", :team-id 3782, :value 4}
{:source "25643", :target "25999", :team-id 3782, :value 4}
{:source "25889", :target "396616", :team-id 3782, :value 4}
{:source "396616", :target "25999", :team-id 3782, :value 4}
{:source "396616", :target "2600085438", :team-id 3782, :value 4}
{:source "276944", :target "25999", :team-id 3782, :value 4}
{:source "25649134797", :target "25864", :team-id 3782, :value 4}
{:source "26216", :target "25649134797", :team-id 3782, :value 4}
{:source "25643", :target "25864", :team-id 3782, :value 4}
{:source "26216", :target "364644", :team-id 3782, :value 4}
{:source "2604225789", :target "364644", :team-id 3782, :value 5}
{:source "276944", :target "25889", :team-id 3782, :value 5}
{:source "25864", :target "276944", :team-id 3782, :value 5}
{:source "276944", :target "25643", :team-id 3782, :value 5}
{:source "25649134797", :target "25999", :team-id 3782, :value 5}
{:source "25999", :target "2604225789", :team-id 3782, :value 5}
{:source "25649134797",
:target "2604225789",
:team-id 3782,
:value 5}
{:source "25643", :target "2600085438", :team-id 3782, :value 5}
{:source "25864", :target "2604225789", :team-id 3782, :value 5}
{:source "2600085438", :target "25643", :team-id 3782, :value 5}
{:source "25999", :target "2600085438", :team-id 3782, :value 5}
{:source "25649134797",
:target "2600085438",
:team-id 3782,
:value 5}
{:source "25999", :target "25643", :team-id 3782, :value 6}
{:source "276944", :target "396616", :team-id 3782, :value 6}
{:source "26216", :target "25864", :team-id 3782, :value 6}
{:source "2604225789", :target "25999", :team-id 3782, :value 6}
{:source "25999", :target "25864", :team-id 3782, :value 6}
{:source "276944", :target "25649134797", :team-id 3782, :value 6}
{:source "25643", :target "364644", :team-id 3782, :value 6}
{:source "25864", :target "26216", :team-id 3782, :value 6}
{:source "25649134797", :target "364644", :team-id 3782, :value 6}
{:source "25649134797", :target "276944", :team-id 3782, :value 6}
{:source "25643", :target "276944", :team-id 3782, :value 6}
{:source "26216", :target "25643", :team-id 3782, :value 7}
{:source "25999", :target "276944", :team-id 3782, :value 7}
{:source "364644", :target "25864", :team-id 3782, :value 8}
{:source "364644", :target "25999", :team-id 3782, :value 8}
{:source "2604225789", :target "25864", :team-id 3782, :value 8}
{:source "364644", :target "25643", :team-id 3782, :value 8}
{:source "25643", :target "25649134797", :team-id 3782, :value 9}
{:source "25643", :target "26216", :team-id 3782, :value 9}
{:source "25649134797", :target "25643", :team-id 3782, :value 9}
{:source "25864", :target "25999", :team-id 3782, :value 9}
{:source "25864", :target "364644", :team-id 3782, :value 11}
{:source "364644", :target "25649134797", :team-id 3782, :value 11}
{:source "25864", :target "25643", :team-id 3782, :value 12}
{:source "396616", :target "25643", :team-id 3782, :value 13}
{:source "25643", :target "396616", :team-id 3782, :value 14}),
:3777
({:source "25716", :target "25919", :team-id 3777, :value 1}
{:source "37896", :target "26138", :team-id 3777, :value 1}
{:source "37896", :target "25809498357", :team-id 3777, :value 1}
{:source "8648625503", :target "26138", :team-id 3777, :value 1}
{:source "37896", :target "290119", :team-id 3777, :value 1}
{:source "26138", :target "25716", :team-id 3777, :value 1}
{:source "478637796", :target "37896", :team-id 3777, :value 1}
{:source "25716", :target "26508", :team-id 3777, :value 1}
{:source "290119", :target "37896", :team-id 3777, :value 1}
{:source "478637796", :target "14990", :team-id 3777, :value 1}
{:source "26512", :target "14990", :team-id 3777, :value 1}
{:source "26138", :target "25809498357", :team-id 3777, :value 1}
{:source "25809498357", :target "290119", :team-id 3777, :value 1}
{:source "37896", :target "8648625503", :team-id 3777, :value 1}
{:source "290119", :target "478637796", :team-id 3777, :value 1}
{:source "26508", :target "290119", :team-id 3777, :value 1}
{:source "26138", :target "8648625503", :team-id 3777, :value 1}
{:source "25716", :target "26512", :team-id 3777, :value 1}
{:source "14990", :target "25919", :team-id 3777, :value 1}
{:source "26512", :target "8648625503", :team-id 3777, :value 1}
{:source "25716", :target "37896", :team-id 3777, :value 1}
{:source "37896", :target "26512", :team-id 3777, :value 1}
{:source "26508", :target "14990", :team-id 3777, :value 2}
{:source "25716", :target "25809498357", :team-id 3777, :value 2}
{:source "290119", :target "25716", :team-id 3777, :value 2}
{:source "14990", :target "37896", :team-id 3777, :value 2}
{:source "290119", :target "14990", :team-id 3777, :value 2}
{:source "26508", :target "8648625503", :team-id 3777, :value 2}
{:source "290119", :target "26512", :team-id 3777, :value 2}
{:source "8648625503",
:target "25809498357",
:team-id 3777,
:value 2}
{:source "26138", :target "478637796", :team-id 3777, :value 2}
{:source "26508", :target "25716", :team-id 3777, :value 2}
{:source "14990", :target "25809498357", :team-id 3777, :value 2}
{:source "26138", :target "14990", :team-id 3777, :value 2}
{:source "478637796", :target "8648625503", :team-id 3777, :value 2}
{:source "478637796", :target "290119", :team-id 3777, :value 2}
{:source "37896", :target "25716", :team-id 3777, :value 2}
{:source "8648625503", :target "26512", :team-id 3777, :value 2}
{:source "25809498357",
:target "8648625503",
:team-id 3777,
:value 2}
{:source "25919", :target "290119", :team-id 3777, :value 2}
{:source "26138", :target "290119", :team-id 3777, :value 2}
{:source "37896", :target "14990", :team-id 3777, :value 3}
{:source "8648625503", :target "14990", :team-id 3777, :value 3}
{:source "25809498357", :target "26512", :team-id 3777, :value 3}
{:source "26508", :target "25809498357", :team-id 3777, :value 3}
{:source "26512", :target "478637796", :team-id 3777, :value 3}
{:source "8648625503", :target "290119", :team-id 3777, :value 3}
{:source "26138", :target "37896", :team-id 3777, :value 3}
{:source "478637796", :target "26512", :team-id 3777, :value 3}
{:source "8648625503", :target "478637796", :team-id 3777, :value 3}
{:source "25716", :target "8648625503", :team-id 3777, :value 3}
{:source "8648625503", :target "25716", :team-id 3777, :value 3}
{:source "14990", :target "478637796", :team-id 3777, :value 3}
{:source "478637796", :target "26508", :team-id 3777, :value 3}
{:source "478637796", :target "26138", :team-id 3777, :value 3}
{:source "290119", :target "25809498357", :team-id 3777, :value 3}
{:source "290119", :target "25919", :team-id 3777, :value 3}
{:source "290119", :target "26508", :team-id 3777, :value 3}
{:source "25716", :target "290119", :team-id 3777, :value 3}
{:source "478637796", :target "25919", :team-id 3777, :value 4}
{:source "25809498357", :target "25919", :team-id 3777, :value 4}
{:source "26512", :target "26138", :team-id 3777, :value 4}
{:source "14990", :target "26508", :team-id 3777, :value 4}
{:source "14990", :target "26138", :team-id 3777, :value 4}
{:source "25809498357",
:target "478637796",
:team-id 3777,
:value 4}
{:source "26512", :target "25809498357", :team-id 3777, :value 4}
{:source "14990", :target "290119", :team-id 3777, :value 5}
{:source "478637796",
:target "25809498357",
:team-id 3777,
:value 5}
{:source "26508", :target "25919", :team-id 3777, :value 5}
{:source "25919", :target "478637796", :team-id 3777, :value 5}
{:source "14990", :target "8648625503", :team-id 3777, :value 5}
{:source "25716", :target "478637796", :team-id 3777, :value 5}
{:source "290119", :target "8648625503", :team-id 3777, :value 5}
{:source "26508", :target "478637796", :team-id 3777, :value 5}
{:source "26138", :target "26508", :team-id 3777, :value 5}
{:source "26508", :target "26138", :team-id 3777, :value 6}
{:source "26138", :target "26512", :team-id 3777, :value 6}
{:source "25919", :target "25716", :team-id 3777, :value 7}
{:source "25809498357", :target "26508", :team-id 3777, :value 7}
{:source "8648625503", :target "25919", :team-id 3777, :value 7}
{:source "26508", :target "26512", :team-id 3777, :value 8}
{:source "8648625503", :target "26508", :team-id 3777, :value 8}
{:source "25919", :target "8648625503", :team-id 3777, :value 11}
{:source "26512", :target "26508", :team-id 3777, :value 11})},
:stats
{:global
{:out-degree {:min 10.0, :max 61.0},
:passes {:min 1, :max 14},
:in-degree {:min 8.0, :max 68.0},
:current_flow_betweenness_centrality
{:min -0.13513518592663346, :max 0.054487530167942805},
:katz-centrality {:min 1.1006381504458114, :max 2.110416319361961},
:degree {:min 18.0, :max 129.0},
:alpha-centrality {:min 1.1006381504458114, :max 2.110416319361961},
:betweenness-centrality {:min 0.0, :max 0.27451973951973946},
:local-clustering-coefficient
{:min 0.7222222222222222, :max 0.9222222222222223},
:closeness-centrality
{:min 0.2564102564102564, :max 0.5882352941176471},
:eigenvector-centrality
{:min 1.510837280909091E-6, :max 4.369705889159273E-5}},
:home
{:out-degree {:min 10.0, :max 34.0},
:average-clustering-coefficient 0.7778860028860027,
:algebraic-connectivity 18.64689096200971,
:global-clustering-coefficient 0.9095354523227384,
:average-node-connectivity 6.654545454545454,
:passes {:min 1, :max 11},
:in-degree {:min 8.0, :max 42.0},
:current_flow_betweenness_centrality
{:min -0.08832920423902048, :max 0.054487530167942805},
:katz-centrality {:min 1.1006381504458114, :max 1.5587935014979057},
:degree {:min 18.0, :max 76.0},
:alpha-centrality
{:min 1.1006381504458114, :max 1.5587935014979057},
:betweenness-centrality
{:min 0.011195286195286196, :max 0.19669312169312164},
:local-clustering-coefficient
{:min 0.7222222222222222, :max 0.8809523809523809},
:closeness-centrality
{:min 0.2702702702702703, :max 0.5882352941176471},
:eigenvector-centrality
{:min 1.510837280909091E-6, :max 1.0122596532727273E-5}},
:away
{:out-degree {:min 22.0, :max 61.0},
:average-clustering-coefficient 0.8757575757575757,
:algebraic-connectivity 40.68263593258109,
:global-clustering-coefficient 0.9811320754716981,
:average-node-connectivity 8.0,
:passes {:min 1, :max 14},
:in-degree {:min 18.0, :max 68.0},
:current_flow_betweenness_centrality
{:min -0.13513518592663346, :max 0.03428734259678151},
:katz-centrality {:min 1.3104027337293283, :max 2.110416319361961},
:degree {:min 40.0, :max 129.0},
:alpha-centrality {:min 1.3104027337293283, :max 2.110416319361961},
:betweenness-centrality {:min 0.0, :max 0.27451973951973946},
:local-clustering-coefficient
{:min 0.8444444444444444, :max 0.9222222222222223},
:closeness-centrality
{:min 0.2564102564102564, :max 0.47619047619047616},
:eigenvector-centrality
{:min 1.3147640737547639E-5, :max 4.369705889159273E-5}}}}
| 42.974242 | 71 | 0.659733 |
96ed00c98b8a6fbd76b3ac2cc9e845db4fc14780 | 880 | edn | edn | doc/webhook-requests/edn/group-chat-member-removed.example.edn | marksto/general-expenses-accountant | de9584f1183dee75e1a0aead7b63e09f5961adea | [
"MIT"
] | 3 | 2021-05-25T13:42:16.000Z | 2022-01-23T15:57:01.000Z | doc/webhook-requests/edn/group-chat-member-removed.example.edn | marksto/general-expenses-accountant | de9584f1183dee75e1a0aead7b63e09f5961adea | [
"MIT"
] | null | null | null | doc/webhook-requests/edn/group-chat-member-removed.example.edn | marksto/general-expenses-accountant | de9584f1183dee75e1a0aead7b63e09f5961adea | [
"MIT"
] | null | null | null | {:update_id 426300767,
:message {:message_id 29,
:from {:id 280000000,
:is_bot false,
:first_name "User",
:last_name "Name",
:username "username",
:language_code "en"},
:chat {:id -480000000,
:title "Test Add",
:type "group",
:all_members_are_administrators true},
:date 1616603393,
:left_chat_participant {:id 290000000,
:is_bot false,
:first_name "Other",
:username "otherusername"},
:left_chat_member {:id 290000000,
:is_bot false,
:first_name "Other",
:username "otherusername"}}}
| 40 | 62 | 0.406818 |
0afc55b12a0b8b86b9bdfa095ad0a7544ebafba9 | 79 | edn | edn | figwheel-main.edn | vodori/Nightlight | 1fa4971245b696b70f9f40bfd773af1a52e32ef5 | [
"Unlicense"
] | 900 | 2016-10-09T02:06:41.000Z | 2022-02-09T20:06:05.000Z | figwheel-main.edn | vodori/Nightlight | 1fa4971245b696b70f9f40bfd773af1a52e32ef5 | [
"Unlicense"
] | 58 | 2016-10-09T13:55:28.000Z | 2019-12-20T18:54:04.000Z | figwheel-main.edn | vodori/Nightlight | 1fa4971245b696b70f9f40bfd773af1a52e32ef5 | [
"Unlicense"
] | 44 | 2016-10-09T06:21:22.000Z | 2020-03-11T19:11:59.000Z | {:open-url "http://localhost:4000"
:css-dirs ["resources/nightlight-public"]}
| 26.333333 | 43 | 0.708861 |
404a6d714a09acd62f2b4964c44d8f59b0a51e62 | 160 | edn | edn | examples/web-figwheel-main/dev.cljs.edn | olymk2/portal | 53d9dc070c024c5eabd5598a325c199144936d1c | [
"MIT"
] | 481 | 2020-06-24T09:51:08.000Z | 2022-03-31T07:14:01.000Z | examples/web-figwheel-main/dev.cljs.edn | olymk2/portal | 53d9dc070c024c5eabd5598a325c199144936d1c | [
"MIT"
] | 68 | 2020-07-21T14:38:18.000Z | 2022-03-30T20:15:10.000Z | examples/web-figwheel-main/dev.cljs.edn | olymk2/portal | 53d9dc070c024c5eabd5598a325c199144936d1c | [
"MIT"
] | 44 | 2020-07-16T01:56:26.000Z | 2022-03-06T18:16:48.000Z | {:output-to "resources/public/cljs-out/dev-main.js"
:optimizations :none
:pretty-print true
:source-map true
:source-map-timestamp true
:main example.app}
| 22.857143 | 51 | 0.75 |
56ebc5bce0bd20ab0535f819a2950113e6555d68 | 6,531 | edn | edn | deps.edn | wardle/clods | 168de00f083c5b6c538375a37cc1a9ec523283ea | [
"Apache-2.0"
] | 8 | 2020-11-10T17:31:41.000Z | 2021-06-18T17:36:25.000Z | deps.edn | wardle/clods | 168de00f083c5b6c538375a37cc1a9ec523283ea | [
"Apache-2.0"
] | 4 | 2021-03-17T14:31:27.000Z | 2021-09-18T11:10:51.000Z | deps.edn | wardle/clods | 168de00f083c5b6c538375a37cc1a9ec523283ea | [
"Apache-2.0"
] | 3 | 2020-11-10T17:31:39.000Z | 2021-03-18T16:43:23.000Z | {:paths ["src" "resources"]
:deps {org.clojure/clojure {:mvn/version "1.10.3"}
org.clojure/core.async {:mvn/version "1.3.610"}
org.clojure/data.csv {:mvn/version "1.0.0"}
org.clojure/data.xml {:mvn/version "0.2.0-alpha6"}
org.clojure/data.zip {:mvn/version "1.0.0"}
org.clojure/tools.logging {:mvn/version "1.1.0"}
com.eldrix/nhspd {:git/url "https://github.com/wardle/nhspd.git"
:sha "8f8807d8778cf5593f63449a78e4bbaaa1804e22"}
com.eldrix/trud {:git/url "https://github.com/wardle/trud.git"
:sha "c73e7dcb4f7420b5e22e528f74c58d884bd6907e"}
cli-matic/cli-matic {:mvn/version "0.4.3"}
clj-bom/clj-bom {:mvn/version "0.1.2"}
clj-http/clj-http {:mvn/version "3.12.1"}
com.taoensso/nippy {:mvn/version "3.1.1"}
com.wsscode/pathom {:git/url "https://github.com/wilkerlucio/pathom3"
:sha "ccb9ed70ac56c87b1e28a4958089c129e8c24fa8"}
org.apache.lucene/lucene-core {:mvn/version "8.8.1"}
org.apache.lucene/lucene-queries {:mvn/version "8.8.1"}}
:aliases {
:pathom-viz {:extra-deps {com.wsscode/pathom-viz-connector {:mvn/version "2021.04.20"}}}
:install {:extra-deps {ch.qos.logback/logback-classic {:mvn/version "1.2.3"}}
:main-opts ["-m" "com.eldrix.clods.install"]}
:nhspd {:extra-deps {ch.qos.logback/logback-classic {:mvn/version "1.2.3"}}
:main-opts ["-m" "com.eldrix.clods.nhspd"]}
:serve {:extra-paths ["serve"]
:extra-deps {io.pedestal/pedestal.service {:mvn/version "0.5.9"}
io.pedestal/pedestal.jetty {:mvn/version "0.5.9"}
ch.qos.logback/logback-classic {:mvn/version "1.2.3"}}
:main-opts ["-m" "com.eldrix.clods.serve"]}
:fhir-r4 {:extra-paths ["fhir_r4"]
:extra-deps {ca.uhn.hapi.fhir/hapi-fhir-base {:mvn/version "5.3.0"}
ca.uhn.hapi.fhir/hapi-fhir-server {:mvn/version "5.3.0"}
ca.uhn.hapi.fhir/hapi-fhir-structures-r4 {:mvn/version "5.3.0"}
ch.qos.logback/logback-classic {:mvn/version "1.2.3"}
io.pedestal/pedestal.jetty {:mvn/version "0.5.9"}
javax.servlet/javax.servlet-api {:mvn/version "4.0.1"}}
:main-opts ["-m" "com.eldrix.clods.fhir.r4.serve"]}
:test {:extra-paths ["test" "test/resources"]
:extra-deps {com.cognitect/test-runner {:git/url "https://github.com/cognitect-labs/test-runner.git"
:sha "b6b3193fcc42659d7e46ecd1884a228993441182"}}
:main-opts ["-m" "cognitect.test-runner"]}
:log {:extra-deps {ch.qos.logback/logback-classic {:mvn/version "1.2.3"}}}
:outdated {:extra-deps {com.github.liquidz/antq {:mvn/version "RELEASE"}}
:main-opts ["-m" "antq.core"]}
:check {:extra-deps {athos/clj-check
{:git/url "https://github.com/athos/clj-check.git"
:sha "518d5a1cbfcd7c952f548e6dbfcb9a4a5faf9062"}}
:main-opts ["-m" "clj-check.check" "src"]}
;; run with clj -M:serve:fhir-r4:check-all to test all codepaths
:check-all {:extra-deps {athos/clj-check
{:git/url "https://github.com/athos/clj-check.git"
:sha "518d5a1cbfcd7c952f548e6dbfcb9a4a5faf9062"}}
:main-opts ["-m" "clj-check.check" "src" "fhir_r4" "serve"]}
:lint/kondo
{:extra-deps {clj-kondo/clj-kondo {:mvn/version "RELEASE"}}
:main-opts ["-m" "clj-kondo.main" "--lint" "src"]}
:lint/eastwood
{:main-opts ["-m" "eastwood.lint" {:source-paths ["src" "fhir_r4" "serve"]}]
:extra-deps {jonase/eastwood {:mvn/version "RELEASE"}}}
:jar {:replace-deps {com.github.seancorfield/depstar {:mvn/version "2.0.211"}}
:exec-fn hf.depstar/jar
:exec-args {:jar "target/clods-v0.1.0.jar"}}
;; build a utility uberjar - just the command-line tools
:uberjar {:replace-deps {com.github.seancorfield/depstar {:mvn/version "2.0.211"}}
:exec-fn hf.depstar/uberjar
:exec-args {:jar "target/clods-full-v0.1.0.jar"
:aot true
:main-class com.eldrix.clods.core}}
:server-uberjar {:replace-deps {com.github.seancorfield/depstar {:mvn/version "2.0.211"}}
:exec-fn hf.depstar/uberjar
:exec-args {:jar "target/clods-rest-server-v0.1.0.jar"
:aliases [:serve]
:aot true
:main-class com.eldrix.clods.serve}}
:fhir-r4-uberjar {:replace-deps {com.github.seancorfield/depstar {:mvn/version "2.0.211"}}
:exec-fn hf.depstar/uberjar
:exec-args {:jar "target/clods-fhir-r4-server-v0.1.0.jar"
:aliases [:fhir-r4]
:aot true
:main-class com.eldrix.clods.fhir.r4.serve}}}}
| 65.31 | 130 | 0.437299 |
448318f3c5f94ec451c3af7d293784af98498021 | 463 | edn | edn | edn/cards/aurora.edn | plural/netrunner-data | b71186e109a77a737c1f597b59b0ae0a64c2ab0f | [
"MIT"
] | 7 | 2018-11-21T13:36:52.000Z | 2022-03-12T21:02:50.000Z | edn/cards/aurora.edn | plural/netrunner-data | b71186e109a77a737c1f597b59b0ae0a64c2ab0f | [
"MIT"
] | 4 | 2019-02-21T00:42:00.000Z | 2021-02-20T22:31:54.000Z | edn/cards/aurora.edn | plural/netrunner-data | b71186e109a77a737c1f597b59b0ae0a64c2ab0f | [
"MIT"
] | 9 | 2019-01-22T21:16:45.000Z | 2021-08-02T14:55:56.000Z | {:cost 3
:deck-limit 3
:faction :criminal
:id "aurora"
:influence-cost 1
:memory-cost 1
:side :runner
:strength 1
:stripped-text "Interface -> 2 credits: Break 1 barrier subroutine. 2 credits: +3 strength."
:stripped-title "Aurora"
:subtype [:icebreaker :fracter]
:text "Interface → <strong>2[credit]:</strong> Break 1 <strong>barrier</strong> subroutine.\n<strong>2[credit]:</strong> +3 strength."
:title "Aurora"
:type :program
:uniqueness false}
| 28.9375 | 135 | 0.706263 |
cca45b96407822713173e3f2ee11506470d80cc9 | 454 | edn | edn | .clj-kondo/config.edn | davidpham87/portal | 0b57ed2969b59fadf5e7149013bdc843f83abab1 | [
"MIT"
] | 481 | 2020-06-24T09:51:08.000Z | 2022-03-31T07:14:01.000Z | .clj-kondo/config.edn | davidpham87/portal | 0b57ed2969b59fadf5e7149013bdc843f83abab1 | [
"MIT"
] | 68 | 2020-07-21T14:38:18.000Z | 2022-03-30T20:15:10.000Z | .clj-kondo/config.edn | davidpham87/portal | 0b57ed2969b59fadf5e7149013bdc843f83abab1 | [
"MIT"
] | 44 | 2020-07-16T01:56:26.000Z | 2022-03-06T18:16:48.000Z | {:linters {:unsorted-required-namespaces {:level :fail}
:unresolved-symbol
{:exclude [(portal.ui.sci.import/sci-import)
(portal.ui.sci.import/import-ns)]}}
:lint-as
{portal.async/let clojure.core/let
portal.sync/let clojure.core/let
reagent.core/with-let clojure.core/let
portal.bench/simple-benchmark clojure.core/let
portal.runtime.macros/extend-type? clojure.core/extend-type}}
| 41.272727 | 63 | 0.65859 |
d944c64179ab533bd420ac2951335ca3d65d5cd5 | 337 | edn | edn | edn/cards/wyldside.edn | plural/netrunner-data | b71186e109a77a737c1f597b59b0ae0a64c2ab0f | [
"MIT"
] | 7 | 2018-11-21T13:36:52.000Z | 2022-03-12T21:02:50.000Z | edn/cards/wyldside.edn | plural/netrunner-data | b71186e109a77a737c1f597b59b0ae0a64c2ab0f | [
"MIT"
] | 4 | 2019-02-21T00:42:00.000Z | 2021-02-20T22:31:54.000Z | edn/cards/wyldside.edn | plural/netrunner-data | b71186e109a77a737c1f597b59b0ae0a64c2ab0f | [
"MIT"
] | 9 | 2019-01-22T21:16:45.000Z | 2021-08-02T14:55:56.000Z | {:cost 3
:deck-limit 3
:faction :anarch
:id "wyldside"
:influence-cost 3
:side :runner
:stripped-text "When your turn begins, draw 2 cards and lose click."
:stripped-title "Wyldside"
:subtype [:location :seedy]
:text "When your turn begins, draw 2 cards and lose [click]."
:title "Wyldside"
:type :resource
:uniqueness true}
| 24.071429 | 69 | 0.706231 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.